* [PATCH v2] ION: Sys_heap: Add cached pool to spead up cached buffer alloc
@ 2016-05-19 3:03 Chen Feng
2016-05-23 22:32 ` Laura Abbott
0 siblings, 1 reply; 5+ messages in thread
From: Chen Feng @ 2016-05-19 3:03 UTC (permalink / raw)
To: puck.chen, gregkh, arve, riandrews, labbott, paul.gortmaker, bmarsh94
Cc: devel, linux-kernel, puck.chen, dan.zhao, suzhuangluan, qijiwen,
oliver.fu, xuyiping, saberlily.xia
Add ion cached pool in system heap. This patch add a cached pool
in system heap. It has a great improvement of alloc for cached
buffer.
With memory pressue alloc test 800MB in userspace used iontest.
The result avg is 577ms. Without patch it's avg is about 883ms.
v1: Makes the cached buffer zeroed before going to pool
v2: Add cached param in pool to distinguish wheather need to flush
cache at a fresh alloc.
Rework the shrink function.
Signed-off-by: Chen Feng <puck.chen@hisilicon.com>
Signed-off-by: Xia Qing <saberlily.xia@hisilicon.com>
Reviewed-by: Fu Jun <oliver.fu@hisilicon.com>
---
drivers/staging/android/ion/ion_page_pool.c | 10 +-
drivers/staging/android/ion/ion_priv.h | 5 +-
drivers/staging/android/ion/ion_system_heap.c | 183 +++++++++++++++++---------
3 files changed, 133 insertions(+), 65 deletions(-)
diff --git a/drivers/staging/android/ion/ion_page_pool.c b/drivers/staging/android/ion/ion_page_pool.c
index 1fe8016..2c5e5c5 100644
--- a/drivers/staging/android/ion/ion_page_pool.c
+++ b/drivers/staging/android/ion/ion_page_pool.c
@@ -30,8 +30,9 @@ static void *ion_page_pool_alloc_pages(struct ion_page_pool *pool)
if (!page)
return NULL;
- ion_pages_sync_for_device(NULL, page, PAGE_SIZE << pool->order,
- DMA_BIDIRECTIONAL);
+ if (!pool->cached)
+ ion_pages_sync_for_device(NULL, page, PAGE_SIZE << pool->order,
+ DMA_BIDIRECTIONAL);
return page;
}
@@ -147,7 +148,8 @@ int ion_page_pool_shrink(struct ion_page_pool *pool, gfp_t gfp_mask,
return freed;
}
-struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order)
+struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order,
+ bool cached)
{
struct ion_page_pool *pool = kmalloc(sizeof(*pool), GFP_KERNEL);
@@ -161,6 +163,8 @@ struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order)
pool->order = order;
mutex_init(&pool->mutex);
plist_node_init(&pool->list, order);
+ if (cached)
+ pool->cached = true;
return pool;
}
diff --git a/drivers/staging/android/ion/ion_priv.h b/drivers/staging/android/ion/ion_priv.h
index 0239883..f3cb8b4 100644
--- a/drivers/staging/android/ion/ion_priv.h
+++ b/drivers/staging/android/ion/ion_priv.h
@@ -360,6 +360,7 @@ void ion_carveout_free(struct ion_heap *heap, ion_phys_addr_t addr,
* @gfp_mask: gfp_mask to use from alloc
* @order: order of pages in the pool
* @list: plist node for list of pools
+ * @cached: it's cached pool or not
*
* Allows you to keep a pool of pre allocated pages to use from your heap.
* Keeping a pool of pages that is ready for dma, ie any cached mapping have
@@ -369,6 +370,7 @@ void ion_carveout_free(struct ion_heap *heap, ion_phys_addr_t addr,
struct ion_page_pool {
int high_count;
int low_count;
+ bool cached;
struct list_head high_items;
struct list_head low_items;
struct mutex mutex;
@@ -377,7 +379,8 @@ struct ion_page_pool {
struct plist_node list;
};
-struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order);
+struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order,
+ bool cached);
void ion_page_pool_destroy(struct ion_page_pool *);
struct page *ion_page_pool_alloc(struct ion_page_pool *);
void ion_page_pool_free(struct ion_page_pool *, struct page *);
diff --git a/drivers/staging/android/ion/ion_system_heap.c b/drivers/staging/android/ion/ion_system_heap.c
index b69dfc7..32a0ebf 100644
--- a/drivers/staging/android/ion/ion_system_heap.c
+++ b/drivers/staging/android/ion/ion_system_heap.c
@@ -26,16 +26,18 @@
#include "ion.h"
#include "ion_priv.h"
+#define NUM_ORDERS ARRAY_SIZE(orders)
+
static gfp_t high_order_gfp_flags = (GFP_HIGHUSER | __GFP_ZERO | __GFP_NOWARN |
__GFP_NORETRY) & ~__GFP_RECLAIM;
static gfp_t low_order_gfp_flags = (GFP_HIGHUSER | __GFP_ZERO | __GFP_NOWARN);
static const unsigned int orders[] = {8, 4, 0};
-static const int num_orders = ARRAY_SIZE(orders);
+
static int order_to_index(unsigned int order)
{
int i;
- for (i = 0; i < num_orders; i++)
+ for (i = 0; i < NUM_ORDERS; i++)
if (order == orders[i])
return i;
BUG();
@@ -49,47 +51,55 @@ static inline unsigned int order_to_size(int order)
struct ion_system_heap {
struct ion_heap heap;
- struct ion_page_pool *pools[0];
+ struct ion_page_pool *uncached_pools[NUM_ORDERS];
+ struct ion_page_pool *cached_pools[NUM_ORDERS];
};
+/**
+ * The page from page-pool are all zeroed before. We need do cache
+ * clean for cached buffer. The uncached buffer are always non-cached
+ * since it's allocated. So no need for non-cached pages.
+ */
static struct page *alloc_buffer_page(struct ion_system_heap *heap,
struct ion_buffer *buffer,
unsigned long order)
{
bool cached = ion_buffer_cached(buffer);
- struct ion_page_pool *pool = heap->pools[order_to_index(order)];
+ struct ion_page_pool *pool;
struct page *page;
- if (!cached) {
- page = ion_page_pool_alloc(pool);
- } else {
- gfp_t gfp_flags = low_order_gfp_flags;
+ if (!cached)
+ pool = heap->uncached_pools[order_to_index(order)];
+ else
+ pool = heap->cached_pools[order_to_index(order)];
- if (order > 4)
- gfp_flags = high_order_gfp_flags;
- page = alloc_pages(gfp_flags | __GFP_COMP, order);
- if (!page)
- return NULL;
- ion_pages_sync_for_device(NULL, page, PAGE_SIZE << order,
- DMA_BIDIRECTIONAL);
- }
+ page = ion_page_pool_alloc(pool);
+ if (cached)
+ ion_pages_sync_for_device(NULL, page, PAGE_SIZE << order,
+ DMA_BIDIRECTIONAL);
return page;
}
static void free_buffer_page(struct ion_system_heap *heap,
struct ion_buffer *buffer, struct page *page)
{
+ struct ion_page_pool *pool;
unsigned int order = compound_order(page);
bool cached = ion_buffer_cached(buffer);
- if (!cached && !(buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE)) {
- struct ion_page_pool *pool = heap->pools[order_to_index(order)];
-
- ion_page_pool_free(pool, page);
- } else {
+ /* go to system */
+ if (buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE) {
__free_pages(page, order);
+ return;
}
+
+ if (!cached)
+ pool = heap->uncached_pools[order_to_index(order)];
+ else
+ pool = heap->cached_pools[order_to_index(order)];
+
+ ion_page_pool_free(pool, page);
}
@@ -101,7 +111,7 @@ static struct page *alloc_largest_available(struct ion_system_heap *heap,
struct page *page;
int i;
- for (i = 0; i < num_orders; i++) {
+ for (i = 0; i < NUM_ORDERS; i++) {
if (size < order_to_size(orders[i]))
continue;
if (max_order < orders[i])
@@ -181,16 +191,11 @@ static void ion_system_heap_free(struct ion_buffer *buffer)
struct ion_system_heap,
heap);
struct sg_table *table = buffer->sg_table;
- bool cached = ion_buffer_cached(buffer);
struct scatterlist *sg;
int i;
- /*
- * uncached pages come from the page pools, zero them before returning
- * for security purposes (other allocations are zerod at
- * alloc time
- */
- if (!cached && !(buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE))
+ /* zero the buffer before goto page pool */
+ if (!(buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE))
ion_heap_buffer_zero(buffer);
for_each_sg(table->sgl, sg, table->nents, i)
@@ -213,6 +218,8 @@ static void ion_system_heap_unmap_dma(struct ion_heap *heap,
static int ion_system_heap_shrink(struct ion_heap *heap, gfp_t gfp_mask,
int nr_to_scan)
{
+ struct ion_page_pool *uncached_pool;
+ struct ion_page_pool *cached_pool;
struct ion_system_heap *sys_heap;
int nr_total = 0;
int i, nr_freed;
@@ -223,20 +230,35 @@ static int ion_system_heap_shrink(struct ion_heap *heap, gfp_t gfp_mask,
if (!nr_to_scan)
only_scan = 1;
- for (i = 0; i < num_orders; i++) {
- struct ion_page_pool *pool = sys_heap->pools[i];
-
- nr_freed = ion_page_pool_shrink(pool, gfp_mask, nr_to_scan);
- nr_total += nr_freed;
-
- if (!only_scan) {
+ for (i = 0; i < NUM_ORDERS; i++) {
+ uncached_pool = sys_heap->uncached_pools[i];
+ cached_pool = sys_heap->cached_pools[i];
+
+ if (only_scan) {
+ nr_total += ion_page_pool_shrink(uncached_pool,
+ gfp_mask,
+ nr_to_scan);
+
+ nr_total += ion_page_pool_shrink(cached_pool,
+ gfp_mask,
+ nr_to_scan);
+ } else {
+ nr_freed = ion_page_pool_shrink(uncached_pool,
+ gfp_mask,
+ nr_to_scan);
nr_to_scan -= nr_freed;
- /* shrink completed */
+ nr_total += nr_freed;
+ if (nr_to_scan <= 0)
+ break;
+ nr_freed = ion_page_pool_shrink(cached_pool,
+ gfp_mask,
+ nr_to_scan);
+ nr_to_scan -= nr_freed;
+ nr_total += nr_freed;
if (nr_to_scan <= 0)
break;
}
}
-
return nr_total;
}
@@ -259,52 +281,89 @@ static int ion_system_heap_debug_show(struct ion_heap *heap, struct seq_file *s,
struct ion_system_heap,
heap);
int i;
+ struct ion_page_pool *pool;
- for (i = 0; i < num_orders; i++) {
- struct ion_page_pool *pool = sys_heap->pools[i];
+ for (i = 0; i < NUM_ORDERS; i++) {
+ pool = sys_heap->uncached_pools[i];
- seq_printf(s, "%d order %u highmem pages in pool = %lu total\n",
+ seq_printf(s, "%d order %u highmem pages uncached %lu total\n",
pool->high_count, pool->order,
(PAGE_SIZE << pool->order) * pool->high_count);
- seq_printf(s, "%d order %u lowmem pages in pool = %lu total\n",
+ seq_printf(s, "%d order %u lowmem pages uncached %lu total\n",
+ pool->low_count, pool->order,
+ (PAGE_SIZE << pool->order) * pool->low_count);
+ }
+
+ for (i = 0; i < NUM_ORDERS; i++) {
+ pool = sys_heap->cached_pools[i];
+
+ seq_printf(s, "%d order %u highmem pages cached %lu total\n",
+ pool->high_count, pool->order,
+ (PAGE_SIZE << pool->order) * pool->high_count);
+ seq_printf(s, "%d order %u lowmem pages cached %lu total\n",
pool->low_count, pool->order,
(PAGE_SIZE << pool->order) * pool->low_count);
}
return 0;
}
+static void ion_system_heap_destroy_pools(struct ion_page_pool **pools)
+{
+ int i;
+
+ for (i = 0; i < NUM_ORDERS; i++)
+ if (pools[i])
+ ion_page_pool_destroy(pools[i]);
+}
+
+static int ion_system_heap_create_pools(struct ion_page_pool **pools,
+ bool cached)
+{
+ int i;
+ gfp_t gfp_flags = low_order_gfp_flags;
+
+ for (i = 0; i < NUM_ORDERS; i++) {
+ struct ion_page_pool *pool;
+
+ if (orders[i] > 4)
+ gfp_flags = high_order_gfp_flags;
+
+ pool = ion_page_pool_create(gfp_flags, orders[i], cached);
+ if (!pool)
+ goto err_create_pool;
+ pools[i] = pool;
+ }
+ return 0;
+
+err_create_pool:
+ ion_system_heap_destroy_pools(pools);
+ return -ENOMEM;
+}
+
struct ion_heap *ion_system_heap_create(struct ion_platform_heap *unused)
{
struct ion_system_heap *heap;
- int i;
- heap = kzalloc(sizeof(struct ion_system_heap) +
- sizeof(struct ion_page_pool *) * num_orders,
- GFP_KERNEL);
+ heap = kzalloc(sizeof(*heap), GFP_KERNEL);
if (!heap)
return ERR_PTR(-ENOMEM);
heap->heap.ops = &system_heap_ops;
heap->heap.type = ION_HEAP_TYPE_SYSTEM;
heap->heap.flags = ION_HEAP_FLAG_DEFER_FREE;
- for (i = 0; i < num_orders; i++) {
- struct ion_page_pool *pool;
- gfp_t gfp_flags = low_order_gfp_flags;
+ if (ion_system_heap_create_pools(heap->uncached_pools, false))
+ goto free_heap;
- if (orders[i] > 4)
- gfp_flags = high_order_gfp_flags;
- pool = ion_page_pool_create(gfp_flags, orders[i]);
- if (!pool)
- goto destroy_pools;
- heap->pools[i] = pool;
- }
+ if (ion_system_heap_create_pools(heap->cached_pools, true))
+ goto destroy_uncached_pools;
heap->heap.debug_show = ion_system_heap_debug_show;
return &heap->heap;
-destroy_pools:
- while (i--)
- ion_page_pool_destroy(heap->pools[i]);
+destroy_uncached_pools:
+ ion_system_heap_destroy_pools(heap->uncached_pools);
+
+free_heap:
kfree(heap);
return ERR_PTR(-ENOMEM);
}
@@ -316,8 +375,10 @@ void ion_system_heap_destroy(struct ion_heap *heap)
heap);
int i;
- for (i = 0; i < num_orders; i++)
- ion_page_pool_destroy(sys_heap->pools[i]);
+ for (i = 0; i < NUM_ORDERS; i++) {
+ ion_page_pool_destroy(sys_heap->uncached_pools[i]);
+ ion_page_pool_destroy(sys_heap->cached_pools[i]);
+ }
kfree(sys_heap);
}
--
1.9.1
^ permalink raw reply related [flat|nested] 5+ messages in thread
* Re: [PATCH v2] ION: Sys_heap: Add cached pool to spead up cached buffer alloc
2016-05-19 3:03 [PATCH v2] ION: Sys_heap: Add cached pool to spead up cached buffer alloc Chen Feng
@ 2016-05-23 22:32 ` Laura Abbott
2016-06-05 8:51 ` Chen Feng
0 siblings, 1 reply; 5+ messages in thread
From: Laura Abbott @ 2016-05-23 22:32 UTC (permalink / raw)
To: Chen Feng, gregkh, arve, riandrews, paul.gortmaker, bmarsh94
Cc: devel, linux-kernel, puck.chen, dan.zhao, suzhuangluan, qijiwen,
oliver.fu, xuyiping, saberlily.xia
On 05/18/2016 08:03 PM, Chen Feng wrote:
> Add ion cached pool in system heap. This patch add a cached pool
> in system heap. It has a great improvement of alloc for cached
> buffer.
>
> With memory pressue alloc test 800MB in userspace used iontest.
> The result avg is 577ms. Without patch it's avg is about 883ms.
>
> v1: Makes the cached buffer zeroed before going to pool
> v2: Add cached param in pool to distinguish wheather need to flush
> cache at a fresh alloc.
> Rework the shrink function.
>
> Signed-off-by: Chen Feng <puck.chen@hisilicon.com>
> Signed-off-by: Xia Qing <saberlily.xia@hisilicon.com>
> Reviewed-by: Fu Jun <oliver.fu@hisilicon.com>
Acked-by: Laura Abbott <labbott@redhat.com>
> ---
> drivers/staging/android/ion/ion_page_pool.c | 10 +-
> drivers/staging/android/ion/ion_priv.h | 5 +-
> drivers/staging/android/ion/ion_system_heap.c | 183 +++++++++++++++++---------
> 3 files changed, 133 insertions(+), 65 deletions(-)
>
> diff --git a/drivers/staging/android/ion/ion_page_pool.c b/drivers/staging/android/ion/ion_page_pool.c
> index 1fe8016..2c5e5c5 100644
> --- a/drivers/staging/android/ion/ion_page_pool.c
> +++ b/drivers/staging/android/ion/ion_page_pool.c
> @@ -30,8 +30,9 @@ static void *ion_page_pool_alloc_pages(struct ion_page_pool *pool)
>
> if (!page)
> return NULL;
> - ion_pages_sync_for_device(NULL, page, PAGE_SIZE << pool->order,
> - DMA_BIDIRECTIONAL);
> + if (!pool->cached)
> + ion_pages_sync_for_device(NULL, page, PAGE_SIZE << pool->order,
> + DMA_BIDIRECTIONAL);
> return page;
> }
>
> @@ -147,7 +148,8 @@ int ion_page_pool_shrink(struct ion_page_pool *pool, gfp_t gfp_mask,
> return freed;
> }
>
> -struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order)
> +struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order,
> + bool cached)
> {
> struct ion_page_pool *pool = kmalloc(sizeof(*pool), GFP_KERNEL);
>
> @@ -161,6 +163,8 @@ struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order)
> pool->order = order;
> mutex_init(&pool->mutex);
> plist_node_init(&pool->list, order);
> + if (cached)
> + pool->cached = true;
>
> return pool;
> }
> diff --git a/drivers/staging/android/ion/ion_priv.h b/drivers/staging/android/ion/ion_priv.h
> index 0239883..f3cb8b4 100644
> --- a/drivers/staging/android/ion/ion_priv.h
> +++ b/drivers/staging/android/ion/ion_priv.h
> @@ -360,6 +360,7 @@ void ion_carveout_free(struct ion_heap *heap, ion_phys_addr_t addr,
> * @gfp_mask: gfp_mask to use from alloc
> * @order: order of pages in the pool
> * @list: plist node for list of pools
> + * @cached: it's cached pool or not
> *
> * Allows you to keep a pool of pre allocated pages to use from your heap.
> * Keeping a pool of pages that is ready for dma, ie any cached mapping have
> @@ -369,6 +370,7 @@ void ion_carveout_free(struct ion_heap *heap, ion_phys_addr_t addr,
> struct ion_page_pool {
> int high_count;
> int low_count;
> + bool cached;
> struct list_head high_items;
> struct list_head low_items;
> struct mutex mutex;
> @@ -377,7 +379,8 @@ struct ion_page_pool {
> struct plist_node list;
> };
>
> -struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order);
> +struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order,
> + bool cached);
> void ion_page_pool_destroy(struct ion_page_pool *);
> struct page *ion_page_pool_alloc(struct ion_page_pool *);
> void ion_page_pool_free(struct ion_page_pool *, struct page *);
> diff --git a/drivers/staging/android/ion/ion_system_heap.c b/drivers/staging/android/ion/ion_system_heap.c
> index b69dfc7..32a0ebf 100644
> --- a/drivers/staging/android/ion/ion_system_heap.c
> +++ b/drivers/staging/android/ion/ion_system_heap.c
> @@ -26,16 +26,18 @@
> #include "ion.h"
> #include "ion_priv.h"
>
> +#define NUM_ORDERS ARRAY_SIZE(orders)
> +
> static gfp_t high_order_gfp_flags = (GFP_HIGHUSER | __GFP_ZERO | __GFP_NOWARN |
> __GFP_NORETRY) & ~__GFP_RECLAIM;
> static gfp_t low_order_gfp_flags = (GFP_HIGHUSER | __GFP_ZERO | __GFP_NOWARN);
> static const unsigned int orders[] = {8, 4, 0};
> -static const int num_orders = ARRAY_SIZE(orders);
> +
> static int order_to_index(unsigned int order)
> {
> int i;
>
> - for (i = 0; i < num_orders; i++)
> + for (i = 0; i < NUM_ORDERS; i++)
> if (order == orders[i])
> return i;
> BUG();
> @@ -49,47 +51,55 @@ static inline unsigned int order_to_size(int order)
>
> struct ion_system_heap {
> struct ion_heap heap;
> - struct ion_page_pool *pools[0];
> + struct ion_page_pool *uncached_pools[NUM_ORDERS];
> + struct ion_page_pool *cached_pools[NUM_ORDERS];
> };
>
> +/**
> + * The page from page-pool are all zeroed before. We need do cache
> + * clean for cached buffer. The uncached buffer are always non-cached
> + * since it's allocated. So no need for non-cached pages.
> + */
> static struct page *alloc_buffer_page(struct ion_system_heap *heap,
> struct ion_buffer *buffer,
> unsigned long order)
> {
> bool cached = ion_buffer_cached(buffer);
> - struct ion_page_pool *pool = heap->pools[order_to_index(order)];
> + struct ion_page_pool *pool;
> struct page *page;
>
> - if (!cached) {
> - page = ion_page_pool_alloc(pool);
> - } else {
> - gfp_t gfp_flags = low_order_gfp_flags;
> + if (!cached)
> + pool = heap->uncached_pools[order_to_index(order)];
> + else
> + pool = heap->cached_pools[order_to_index(order)];
>
> - if (order > 4)
> - gfp_flags = high_order_gfp_flags;
> - page = alloc_pages(gfp_flags | __GFP_COMP, order);
> - if (!page)
> - return NULL;
> - ion_pages_sync_for_device(NULL, page, PAGE_SIZE << order,
> - DMA_BIDIRECTIONAL);
> - }
> + page = ion_page_pool_alloc(pool);
>
> + if (cached)
> + ion_pages_sync_for_device(NULL, page, PAGE_SIZE << order,
> + DMA_BIDIRECTIONAL);
> return page;
> }
>
> static void free_buffer_page(struct ion_system_heap *heap,
> struct ion_buffer *buffer, struct page *page)
> {
> + struct ion_page_pool *pool;
> unsigned int order = compound_order(page);
> bool cached = ion_buffer_cached(buffer);
>
> - if (!cached && !(buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE)) {
> - struct ion_page_pool *pool = heap->pools[order_to_index(order)];
> -
> - ion_page_pool_free(pool, page);
> - } else {
> + /* go to system */
> + if (buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE) {
> __free_pages(page, order);
> + return;
> }
> +
> + if (!cached)
> + pool = heap->uncached_pools[order_to_index(order)];
> + else
> + pool = heap->cached_pools[order_to_index(order)];
> +
> + ion_page_pool_free(pool, page);
> }
>
>
> @@ -101,7 +111,7 @@ static struct page *alloc_largest_available(struct ion_system_heap *heap,
> struct page *page;
> int i;
>
> - for (i = 0; i < num_orders; i++) {
> + for (i = 0; i < NUM_ORDERS; i++) {
> if (size < order_to_size(orders[i]))
> continue;
> if (max_order < orders[i])
> @@ -181,16 +191,11 @@ static void ion_system_heap_free(struct ion_buffer *buffer)
> struct ion_system_heap,
> heap);
> struct sg_table *table = buffer->sg_table;
> - bool cached = ion_buffer_cached(buffer);
> struct scatterlist *sg;
> int i;
>
> - /*
> - * uncached pages come from the page pools, zero them before returning
> - * for security purposes (other allocations are zerod at
> - * alloc time
> - */
> - if (!cached && !(buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE))
> + /* zero the buffer before goto page pool */
> + if (!(buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE))
> ion_heap_buffer_zero(buffer);
>
> for_each_sg(table->sgl, sg, table->nents, i)
> @@ -213,6 +218,8 @@ static void ion_system_heap_unmap_dma(struct ion_heap *heap,
> static int ion_system_heap_shrink(struct ion_heap *heap, gfp_t gfp_mask,
> int nr_to_scan)
> {
> + struct ion_page_pool *uncached_pool;
> + struct ion_page_pool *cached_pool;
> struct ion_system_heap *sys_heap;
> int nr_total = 0;
> int i, nr_freed;
> @@ -223,20 +230,35 @@ static int ion_system_heap_shrink(struct ion_heap *heap, gfp_t gfp_mask,
> if (!nr_to_scan)
> only_scan = 1;
>
> - for (i = 0; i < num_orders; i++) {
> - struct ion_page_pool *pool = sys_heap->pools[i];
> -
> - nr_freed = ion_page_pool_shrink(pool, gfp_mask, nr_to_scan);
> - nr_total += nr_freed;
> -
> - if (!only_scan) {
> + for (i = 0; i < NUM_ORDERS; i++) {
> + uncached_pool = sys_heap->uncached_pools[i];
> + cached_pool = sys_heap->cached_pools[i];
> +
> + if (only_scan) {
> + nr_total += ion_page_pool_shrink(uncached_pool,
> + gfp_mask,
> + nr_to_scan);
> +
> + nr_total += ion_page_pool_shrink(cached_pool,
> + gfp_mask,
> + nr_to_scan);
> + } else {
> + nr_freed = ion_page_pool_shrink(uncached_pool,
> + gfp_mask,
> + nr_to_scan);
> nr_to_scan -= nr_freed;
> - /* shrink completed */
> + nr_total += nr_freed;
> + if (nr_to_scan <= 0)
> + break;
> + nr_freed = ion_page_pool_shrink(cached_pool,
> + gfp_mask,
> + nr_to_scan);
> + nr_to_scan -= nr_freed;
> + nr_total += nr_freed;
> if (nr_to_scan <= 0)
> break;
> }
> }
> -
> return nr_total;
> }
>
> @@ -259,52 +281,89 @@ static int ion_system_heap_debug_show(struct ion_heap *heap, struct seq_file *s,
> struct ion_system_heap,
> heap);
> int i;
> + struct ion_page_pool *pool;
>
> - for (i = 0; i < num_orders; i++) {
> - struct ion_page_pool *pool = sys_heap->pools[i];
> + for (i = 0; i < NUM_ORDERS; i++) {
> + pool = sys_heap->uncached_pools[i];
>
> - seq_printf(s, "%d order %u highmem pages in pool = %lu total\n",
> + seq_printf(s, "%d order %u highmem pages uncached %lu total\n",
> pool->high_count, pool->order,
> (PAGE_SIZE << pool->order) * pool->high_count);
> - seq_printf(s, "%d order %u lowmem pages in pool = %lu total\n",
> + seq_printf(s, "%d order %u lowmem pages uncached %lu total\n",
> + pool->low_count, pool->order,
> + (PAGE_SIZE << pool->order) * pool->low_count);
> + }
> +
> + for (i = 0; i < NUM_ORDERS; i++) {
> + pool = sys_heap->cached_pools[i];
> +
> + seq_printf(s, "%d order %u highmem pages cached %lu total\n",
> + pool->high_count, pool->order,
> + (PAGE_SIZE << pool->order) * pool->high_count);
> + seq_printf(s, "%d order %u lowmem pages cached %lu total\n",
> pool->low_count, pool->order,
> (PAGE_SIZE << pool->order) * pool->low_count);
> }
> return 0;
> }
>
> +static void ion_system_heap_destroy_pools(struct ion_page_pool **pools)
> +{
> + int i;
> +
> + for (i = 0; i < NUM_ORDERS; i++)
> + if (pools[i])
> + ion_page_pool_destroy(pools[i]);
> +}
> +
> +static int ion_system_heap_create_pools(struct ion_page_pool **pools,
> + bool cached)
> +{
> + int i;
> + gfp_t gfp_flags = low_order_gfp_flags;
> +
> + for (i = 0; i < NUM_ORDERS; i++) {
> + struct ion_page_pool *pool;
> +
> + if (orders[i] > 4)
> + gfp_flags = high_order_gfp_flags;
> +
> + pool = ion_page_pool_create(gfp_flags, orders[i], cached);
> + if (!pool)
> + goto err_create_pool;
> + pools[i] = pool;
> + }
> + return 0;
> +
> +err_create_pool:
> + ion_system_heap_destroy_pools(pools);
> + return -ENOMEM;
> +}
> +
> struct ion_heap *ion_system_heap_create(struct ion_platform_heap *unused)
> {
> struct ion_system_heap *heap;
> - int i;
>
> - heap = kzalloc(sizeof(struct ion_system_heap) +
> - sizeof(struct ion_page_pool *) * num_orders,
> - GFP_KERNEL);
> + heap = kzalloc(sizeof(*heap), GFP_KERNEL);
> if (!heap)
> return ERR_PTR(-ENOMEM);
> heap->heap.ops = &system_heap_ops;
> heap->heap.type = ION_HEAP_TYPE_SYSTEM;
> heap->heap.flags = ION_HEAP_FLAG_DEFER_FREE;
>
> - for (i = 0; i < num_orders; i++) {
> - struct ion_page_pool *pool;
> - gfp_t gfp_flags = low_order_gfp_flags;
> + if (ion_system_heap_create_pools(heap->uncached_pools, false))
> + goto free_heap;
>
> - if (orders[i] > 4)
> - gfp_flags = high_order_gfp_flags;
> - pool = ion_page_pool_create(gfp_flags, orders[i]);
> - if (!pool)
> - goto destroy_pools;
> - heap->pools[i] = pool;
> - }
> + if (ion_system_heap_create_pools(heap->cached_pools, true))
> + goto destroy_uncached_pools;
>
> heap->heap.debug_show = ion_system_heap_debug_show;
> return &heap->heap;
>
> -destroy_pools:
> - while (i--)
> - ion_page_pool_destroy(heap->pools[i]);
> +destroy_uncached_pools:
> + ion_system_heap_destroy_pools(heap->uncached_pools);
> +
> +free_heap:
> kfree(heap);
> return ERR_PTR(-ENOMEM);
> }
> @@ -316,8 +375,10 @@ void ion_system_heap_destroy(struct ion_heap *heap)
> heap);
> int i;
>
> - for (i = 0; i < num_orders; i++)
> - ion_page_pool_destroy(sys_heap->pools[i]);
> + for (i = 0; i < NUM_ORDERS; i++) {
> + ion_page_pool_destroy(sys_heap->uncached_pools[i]);
> + ion_page_pool_destroy(sys_heap->cached_pools[i]);
> + }
> kfree(sys_heap);
> }
>
>
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH v2] ION: Sys_heap: Add cached pool to spead up cached buffer alloc
2016-05-23 22:32 ` Laura Abbott
@ 2016-06-05 8:51 ` Chen Feng
2016-06-05 15:02 ` Greg KH
0 siblings, 1 reply; 5+ messages in thread
From: Chen Feng @ 2016-06-05 8:51 UTC (permalink / raw)
To: Laura Abbott, Chen Feng, gregkh, arve, riandrews, paul.gortmaker,
bmarsh94
Cc: devel, linux-kernel, dan.zhao, suzhuangluan, qijiwen, oliver.fu,
xuyiping, saberlily.xia
Hi Greg,
Can you take this patch?
Thanks
On 2016年05月24日 06:32, Laura Abbott wrote:
> On 05/18/2016 08:03 PM, Chen Feng wrote:
>> Add ion cached pool in system heap. This patch add a cached pool
>> in system heap. It has a great improvement of alloc for cached
>> buffer.
>>
>> With memory pressue alloc test 800MB in userspace used iontest.
>> The result avg is 577ms. Without patch it's avg is about 883ms.
>>
>> v1: Makes the cached buffer zeroed before going to pool
>> v2: Add cached param in pool to distinguish wheather need to flush
>> cache at a fresh alloc.
>> Rework the shrink function.
>>
>> Signed-off-by: Chen Feng <puck.chen@hisilicon.com>
>> Signed-off-by: Xia Qing <saberlily.xia@hisilicon.com>
>> Reviewed-by: Fu Jun <oliver.fu@hisilicon.com>
>
> Acked-by: Laura Abbott <labbott@redhat.com>
>
>> ---
>> drivers/staging/android/ion/ion_page_pool.c | 10 +-
>> drivers/staging/android/ion/ion_priv.h | 5 +-
>> drivers/staging/android/ion/ion_system_heap.c | 183 +++++++++++++++++---------
>> 3 files changed, 133 insertions(+), 65 deletions(-)
>>
>> diff --git a/drivers/staging/android/ion/ion_page_pool.c b/drivers/staging/android/ion/ion_page_pool.c
>> index 1fe8016..2c5e5c5 100644
>> --- a/drivers/staging/android/ion/ion_page_pool.c
>> +++ b/drivers/staging/android/ion/ion_page_pool.c
>> @@ -30,8 +30,9 @@ static void *ion_page_pool_alloc_pages(struct ion_page_pool *pool)
>>
>> if (!page)
>> return NULL;
>> - ion_pages_sync_for_device(NULL, page, PAGE_SIZE << pool->order,
>> - DMA_BIDIRECTIONAL);
>> + if (!pool->cached)
>> + ion_pages_sync_for_device(NULL, page, PAGE_SIZE << pool->order,
>> + DMA_BIDIRECTIONAL);
>> return page;
>> }
>>
>> @@ -147,7 +148,8 @@ int ion_page_pool_shrink(struct ion_page_pool *pool, gfp_t gfp_mask,
>> return freed;
>> }
>>
>> -struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order)
>> +struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order,
>> + bool cached)
>> {
>> struct ion_page_pool *pool = kmalloc(sizeof(*pool), GFP_KERNEL);
>>
>> @@ -161,6 +163,8 @@ struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order)
>> pool->order = order;
>> mutex_init(&pool->mutex);
>> plist_node_init(&pool->list, order);
>> + if (cached)
>> + pool->cached = true;
>>
>> return pool;
>> }
>> diff --git a/drivers/staging/android/ion/ion_priv.h b/drivers/staging/android/ion/ion_priv.h
>> index 0239883..f3cb8b4 100644
>> --- a/drivers/staging/android/ion/ion_priv.h
>> +++ b/drivers/staging/android/ion/ion_priv.h
>> @@ -360,6 +360,7 @@ void ion_carveout_free(struct ion_heap *heap, ion_phys_addr_t addr,
>> * @gfp_mask: gfp_mask to use from alloc
>> * @order: order of pages in the pool
>> * @list: plist node for list of pools
>> + * @cached: it's cached pool or not
>> *
>> * Allows you to keep a pool of pre allocated pages to use from your heap.
>> * Keeping a pool of pages that is ready for dma, ie any cached mapping have
>> @@ -369,6 +370,7 @@ void ion_carveout_free(struct ion_heap *heap, ion_phys_addr_t addr,
>> struct ion_page_pool {
>> int high_count;
>> int low_count;
>> + bool cached;
>> struct list_head high_items;
>> struct list_head low_items;
>> struct mutex mutex;
>> @@ -377,7 +379,8 @@ struct ion_page_pool {
>> struct plist_node list;
>> };
>>
>> -struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order);
>> +struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order,
>> + bool cached);
>> void ion_page_pool_destroy(struct ion_page_pool *);
>> struct page *ion_page_pool_alloc(struct ion_page_pool *);
>> void ion_page_pool_free(struct ion_page_pool *, struct page *);
>> diff --git a/drivers/staging/android/ion/ion_system_heap.c b/drivers/staging/android/ion/ion_system_heap.c
>> index b69dfc7..32a0ebf 100644
>> --- a/drivers/staging/android/ion/ion_system_heap.c
>> +++ b/drivers/staging/android/ion/ion_system_heap.c
>> @@ -26,16 +26,18 @@
>> #include "ion.h"
>> #include "ion_priv.h"
>>
>> +#define NUM_ORDERS ARRAY_SIZE(orders)
>> +
>> static gfp_t high_order_gfp_flags = (GFP_HIGHUSER | __GFP_ZERO | __GFP_NOWARN |
>> __GFP_NORETRY) & ~__GFP_RECLAIM;
>> static gfp_t low_order_gfp_flags = (GFP_HIGHUSER | __GFP_ZERO | __GFP_NOWARN);
>> static const unsigned int orders[] = {8, 4, 0};
>> -static const int num_orders = ARRAY_SIZE(orders);
>> +
>> static int order_to_index(unsigned int order)
>> {
>> int i;
>>
>> - for (i = 0; i < num_orders; i++)
>> + for (i = 0; i < NUM_ORDERS; i++)
>> if (order == orders[i])
>> return i;
>> BUG();
>> @@ -49,47 +51,55 @@ static inline unsigned int order_to_size(int order)
>>
>> struct ion_system_heap {
>> struct ion_heap heap;
>> - struct ion_page_pool *pools[0];
>> + struct ion_page_pool *uncached_pools[NUM_ORDERS];
>> + struct ion_page_pool *cached_pools[NUM_ORDERS];
>> };
>>
>> +/**
>> + * The page from page-pool are all zeroed before. We need do cache
>> + * clean for cached buffer. The uncached buffer are always non-cached
>> + * since it's allocated. So no need for non-cached pages.
>> + */
>> static struct page *alloc_buffer_page(struct ion_system_heap *heap,
>> struct ion_buffer *buffer,
>> unsigned long order)
>> {
>> bool cached = ion_buffer_cached(buffer);
>> - struct ion_page_pool *pool = heap->pools[order_to_index(order)];
>> + struct ion_page_pool *pool;
>> struct page *page;
>>
>> - if (!cached) {
>> - page = ion_page_pool_alloc(pool);
>> - } else {
>> - gfp_t gfp_flags = low_order_gfp_flags;
>> + if (!cached)
>> + pool = heap->uncached_pools[order_to_index(order)];
>> + else
>> + pool = heap->cached_pools[order_to_index(order)];
>>
>> - if (order > 4)
>> - gfp_flags = high_order_gfp_flags;
>> - page = alloc_pages(gfp_flags | __GFP_COMP, order);
>> - if (!page)
>> - return NULL;
>> - ion_pages_sync_for_device(NULL, page, PAGE_SIZE << order,
>> - DMA_BIDIRECTIONAL);
>> - }
>> + page = ion_page_pool_alloc(pool);
>>
>> + if (cached)
>> + ion_pages_sync_for_device(NULL, page, PAGE_SIZE << order,
>> + DMA_BIDIRECTIONAL);
>> return page;
>> }
>>
>> static void free_buffer_page(struct ion_system_heap *heap,
>> struct ion_buffer *buffer, struct page *page)
>> {
>> + struct ion_page_pool *pool;
>> unsigned int order = compound_order(page);
>> bool cached = ion_buffer_cached(buffer);
>>
>> - if (!cached && !(buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE)) {
>> - struct ion_page_pool *pool = heap->pools[order_to_index(order)];
>> -
>> - ion_page_pool_free(pool, page);
>> - } else {
>> + /* go to system */
>> + if (buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE) {
>> __free_pages(page, order);
>> + return;
>> }
>> +
>> + if (!cached)
>> + pool = heap->uncached_pools[order_to_index(order)];
>> + else
>> + pool = heap->cached_pools[order_to_index(order)];
>> +
>> + ion_page_pool_free(pool, page);
>> }
>>
>>
>> @@ -101,7 +111,7 @@ static struct page *alloc_largest_available(struct ion_system_heap *heap,
>> struct page *page;
>> int i;
>>
>> - for (i = 0; i < num_orders; i++) {
>> + for (i = 0; i < NUM_ORDERS; i++) {
>> if (size < order_to_size(orders[i]))
>> continue;
>> if (max_order < orders[i])
>> @@ -181,16 +191,11 @@ static void ion_system_heap_free(struct ion_buffer *buffer)
>> struct ion_system_heap,
>> heap);
>> struct sg_table *table = buffer->sg_table;
>> - bool cached = ion_buffer_cached(buffer);
>> struct scatterlist *sg;
>> int i;
>>
>> - /*
>> - * uncached pages come from the page pools, zero them before returning
>> - * for security purposes (other allocations are zerod at
>> - * alloc time
>> - */
>> - if (!cached && !(buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE))
>> + /* zero the buffer before goto page pool */
>> + if (!(buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE))
>> ion_heap_buffer_zero(buffer);
>>
>> for_each_sg(table->sgl, sg, table->nents, i)
>> @@ -213,6 +218,8 @@ static void ion_system_heap_unmap_dma(struct ion_heap *heap,
>> static int ion_system_heap_shrink(struct ion_heap *heap, gfp_t gfp_mask,
>> int nr_to_scan)
>> {
>> + struct ion_page_pool *uncached_pool;
>> + struct ion_page_pool *cached_pool;
>> struct ion_system_heap *sys_heap;
>> int nr_total = 0;
>> int i, nr_freed;
>> @@ -223,20 +230,35 @@ static int ion_system_heap_shrink(struct ion_heap *heap, gfp_t gfp_mask,
>> if (!nr_to_scan)
>> only_scan = 1;
>>
>> - for (i = 0; i < num_orders; i++) {
>> - struct ion_page_pool *pool = sys_heap->pools[i];
>> -
>> - nr_freed = ion_page_pool_shrink(pool, gfp_mask, nr_to_scan);
>> - nr_total += nr_freed;
>> -
>> - if (!only_scan) {
>> + for (i = 0; i < NUM_ORDERS; i++) {
>> + uncached_pool = sys_heap->uncached_pools[i];
>> + cached_pool = sys_heap->cached_pools[i];
>> +
>> + if (only_scan) {
>> + nr_total += ion_page_pool_shrink(uncached_pool,
>> + gfp_mask,
>> + nr_to_scan);
>> +
>> + nr_total += ion_page_pool_shrink(cached_pool,
>> + gfp_mask,
>> + nr_to_scan);
>> + } else {
>> + nr_freed = ion_page_pool_shrink(uncached_pool,
>> + gfp_mask,
>> + nr_to_scan);
>> nr_to_scan -= nr_freed;
>> - /* shrink completed */
>> + nr_total += nr_freed;
>> + if (nr_to_scan <= 0)
>> + break;
>> + nr_freed = ion_page_pool_shrink(cached_pool,
>> + gfp_mask,
>> + nr_to_scan);
>> + nr_to_scan -= nr_freed;
>> + nr_total += nr_freed;
>> if (nr_to_scan <= 0)
>> break;
>> }
>> }
>> -
>> return nr_total;
>> }
>>
>> @@ -259,52 +281,89 @@ static int ion_system_heap_debug_show(struct ion_heap *heap, struct seq_file *s,
>> struct ion_system_heap,
>> heap);
>> int i;
>> + struct ion_page_pool *pool;
>>
>> - for (i = 0; i < num_orders; i++) {
>> - struct ion_page_pool *pool = sys_heap->pools[i];
>> + for (i = 0; i < NUM_ORDERS; i++) {
>> + pool = sys_heap->uncached_pools[i];
>>
>> - seq_printf(s, "%d order %u highmem pages in pool = %lu total\n",
>> + seq_printf(s, "%d order %u highmem pages uncached %lu total\n",
>> pool->high_count, pool->order,
>> (PAGE_SIZE << pool->order) * pool->high_count);
>> - seq_printf(s, "%d order %u lowmem pages in pool = %lu total\n",
>> + seq_printf(s, "%d order %u lowmem pages uncached %lu total\n",
>> + pool->low_count, pool->order,
>> + (PAGE_SIZE << pool->order) * pool->low_count);
>> + }
>> +
>> + for (i = 0; i < NUM_ORDERS; i++) {
>> + pool = sys_heap->cached_pools[i];
>> +
>> + seq_printf(s, "%d order %u highmem pages cached %lu total\n",
>> + pool->high_count, pool->order,
>> + (PAGE_SIZE << pool->order) * pool->high_count);
>> + seq_printf(s, "%d order %u lowmem pages cached %lu total\n",
>> pool->low_count, pool->order,
>> (PAGE_SIZE << pool->order) * pool->low_count);
>> }
>> return 0;
>> }
>>
>> +static void ion_system_heap_destroy_pools(struct ion_page_pool **pools)
>> +{
>> + int i;
>> +
>> + for (i = 0; i < NUM_ORDERS; i++)
>> + if (pools[i])
>> + ion_page_pool_destroy(pools[i]);
>> +}
>> +
>> +static int ion_system_heap_create_pools(struct ion_page_pool **pools,
>> + bool cached)
>> +{
>> + int i;
>> + gfp_t gfp_flags = low_order_gfp_flags;
>> +
>> + for (i = 0; i < NUM_ORDERS; i++) {
>> + struct ion_page_pool *pool;
>> +
>> + if (orders[i] > 4)
>> + gfp_flags = high_order_gfp_flags;
>> +
>> + pool = ion_page_pool_create(gfp_flags, orders[i], cached);
>> + if (!pool)
>> + goto err_create_pool;
>> + pools[i] = pool;
>> + }
>> + return 0;
>> +
>> +err_create_pool:
>> + ion_system_heap_destroy_pools(pools);
>> + return -ENOMEM;
>> +}
>> +
>> struct ion_heap *ion_system_heap_create(struct ion_platform_heap *unused)
>> {
>> struct ion_system_heap *heap;
>> - int i;
>>
>> - heap = kzalloc(sizeof(struct ion_system_heap) +
>> - sizeof(struct ion_page_pool *) * num_orders,
>> - GFP_KERNEL);
>> + heap = kzalloc(sizeof(*heap), GFP_KERNEL);
>> if (!heap)
>> return ERR_PTR(-ENOMEM);
>> heap->heap.ops = &system_heap_ops;
>> heap->heap.type = ION_HEAP_TYPE_SYSTEM;
>> heap->heap.flags = ION_HEAP_FLAG_DEFER_FREE;
>>
>> - for (i = 0; i < num_orders; i++) {
>> - struct ion_page_pool *pool;
>> - gfp_t gfp_flags = low_order_gfp_flags;
>> + if (ion_system_heap_create_pools(heap->uncached_pools, false))
>> + goto free_heap;
>>
>> - if (orders[i] > 4)
>> - gfp_flags = high_order_gfp_flags;
>> - pool = ion_page_pool_create(gfp_flags, orders[i]);
>> - if (!pool)
>> - goto destroy_pools;
>> - heap->pools[i] = pool;
>> - }
>> + if (ion_system_heap_create_pools(heap->cached_pools, true))
>> + goto destroy_uncached_pools;
>>
>> heap->heap.debug_show = ion_system_heap_debug_show;
>> return &heap->heap;
>>
>> -destroy_pools:
>> - while (i--)
>> - ion_page_pool_destroy(heap->pools[i]);
>> +destroy_uncached_pools:
>> + ion_system_heap_destroy_pools(heap->uncached_pools);
>> +
>> +free_heap:
>> kfree(heap);
>> return ERR_PTR(-ENOMEM);
>> }
>> @@ -316,8 +375,10 @@ void ion_system_heap_destroy(struct ion_heap *heap)
>> heap);
>> int i;
>>
>> - for (i = 0; i < num_orders; i++)
>> - ion_page_pool_destroy(sys_heap->pools[i]);
>> + for (i = 0; i < NUM_ORDERS; i++) {
>> + ion_page_pool_destroy(sys_heap->uncached_pools[i]);
>> + ion_page_pool_destroy(sys_heap->cached_pools[i]);
>> + }
>> kfree(sys_heap);
>> }
>>
>>
>
>
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH v2] ION: Sys_heap: Add cached pool to spead up cached buffer alloc
2016-06-05 8:51 ` Chen Feng
@ 2016-06-05 15:02 ` Greg KH
2016-06-18 3:21 ` Chen Feng
0 siblings, 1 reply; 5+ messages in thread
From: Greg KH @ 2016-06-05 15:02 UTC (permalink / raw)
To: Chen Feng
Cc: Laura Abbott, Chen Feng, arve, riandrews, paul.gortmaker,
bmarsh94, devel, dan.zhao, xuyiping, suzhuangluan, linux-kernel,
saberlily.xia, oliver.fu, qijiwen
On Sun, Jun 05, 2016 at 04:51:23PM +0800, Chen Feng wrote:
> Hi Greg,
>
> Can you take this patch?
It's in my queue, please wait, staging patches are at the bottom of it,
rightfully so...
thanks,
greg k-h
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH v2] ION: Sys_heap: Add cached pool to spead up cached buffer alloc
2016-06-05 15:02 ` Greg KH
@ 2016-06-18 3:21 ` Chen Feng
0 siblings, 0 replies; 5+ messages in thread
From: Chen Feng @ 2016-06-18 3:21 UTC (permalink / raw)
To: Greg KH, Chen Feng
Cc: Laura Abbott, arve, riandrews, paul.gortmaker, bmarsh94, devel,
dan.zhao, xuyiping, suzhuangluan, linux-kernel, saberlily.xia,
oliver.fu, qijiwen
Greg,
I checkout your staging tree[1].
Not find this patch. Can you take it.... thanks!
[1]git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging.git
On 2016/6/5 23:02, Greg KH wrote:
> On Sun, Jun 05, 2016 at 04:51:23PM +0800, Chen Feng wrote:
>> Hi Greg,
>>
>> Can you take this patch?
>
> It's in my queue, please wait, staging patches are at the bottom of it,
> rightfully so...
>
> thanks,
>
> greg k-h
>
> .
>
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2016-06-18 3:21 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2016-05-19 3:03 [PATCH v2] ION: Sys_heap: Add cached pool to spead up cached buffer alloc Chen Feng
2016-05-23 22:32 ` Laura Abbott
2016-06-05 8:51 ` Chen Feng
2016-06-05 15:02 ` Greg KH
2016-06-18 3:21 ` Chen Feng
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).