radix tree test framework additions
v2 cover radix tree test framework additions
Increase the functionality to the radix tree test framework for use by the lib/test_maple_tree.c
These patches were first presented as part of the maple tree patch set. Changes since the maple tree patch set:
- Both bulk APIs are now in the same patch
- Relocated nr_tallocated from maple tree patch
Changes from v1:
- Dropped two unnecessary patches - Thanks Matthew Wilcox
- Separate pr_err and kmem_cache_set_non_kernel() into their own patches as suggested by Suren Baghdasaryan
- Change allocation counts to be per struct kmem_cache - Thanks Suren Baghdasaryan
- Fix slab bulk API issue when not aligned - Thanks Suren Baghdasaryan
- Added a test for the bulk API
Liam R. Howlett (4):
radix tree test suite: Add pr_err define
radix tree test suite: Add kmem_cache_set_non_kernel() radix tree test suite: Add allocation counts and size to kmem_cache radix tree test suite: Add support for slab bulk APIs
tools/testing/radix-tree/linux.c | 160 +++++++++++++++++++++++- tools/testing/radix-tree/linux/kernel.h | 1 + tools/testing/radix-tree/linux/slab.h | 4 + 3 files changed, 161 insertions(+), 4 deletions(-)
Signature · 1 line
2.30.2
PATCH v2 1/4 radix tree test suite: Add pr_err define
define pr_err to printk
--- tools/testing/radix-tree/linux/kernel.h | 1 + 1 file changed, 1 insertion(+)
tools/testing/radix-tree/linux/kernel.h +1 -0
@@ -14,6 +14,7 @@#include "../../../include/linux/kconfig.h" #define printk printf +#define pr_err printk#define pr_info printk#define pr_debug printk#define pr_cont printk
Signature · 1 line
2.30.2
PATCH v2 2/4 radix tree test suite: Add kmem_cache_set_non_kernel()
In reply to Liam Howlettkmem_cache_set_non_kernel() is a mechanism to allow a certain number of kmem_cache_alloc requests to succeed even when GFP_KERNEL is not set in the flags. This functionality allows for testing different paths though the code.
--- tools/testing/radix-tree/linux.c | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-)
tools/testing/radix-tree/linux.c +13 -2
@@ -24,14 +24,24 @@ struct kmem_cache {int nr_objs;void *objs;void (*ctor)(void *); +unsigned int non_kernel; }; +void kmem_cache_set_non_kernel (struct kmem_cache *cachep,unsigned int val) +{ + cachep->non_kernel = val; +} +void *kmem_cache_alloc (struct kmem_cache *cachep,int gfp) {void *p; -if (!(gfp & __GFP_DIRECT_RECLAIM)) -return NULL ; +if (!(gfp & __GFP_DIRECT_RECLAIM)) { +if (!cachep->non_kernel) +return NULL ; + + cachep->non_kernel--; + }pthread_mutex_lock (&cachep->lock);if (cachep->nr_objs) {
@@ -116,5 +126,6 @@ kmem_cache_create(const char *name, unsigned int size, unsigned int align, ret->nr_objs =0 ; ret->objs =NULL ; ret->ctor = ctor; + ret->non_kernel =0 ;return ret; }
Signature · 1 line
2.30.2
PATCH v2 3/4 radix tree test suite: Add allocation counts and size to kmem_cache
In reply to Liam HowlettAdd functions to get the number of allocations, and total allocations from a kmem_cache. Also add a function to get the allocated size and a way to zero the total allocations.
--- tools/testing/radix-tree/linux.c | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+)
tools/testing/radix-tree/linux.c +27 -0
@@ -25,6 +25,8 @@ struct kmem_cache {void *objs;void (*ctor)(void *);unsigned int non_kernel; +unsigned long nr_allocated; +unsigned long nr_tallocated; };void kmem_cache_set_non_kernel (struct kmem_cache *cachep,unsigned int val)
@@ -32,6 +34,26 @@ void kmem_cache_set_non_kernel(struct kmem_cache *cachep, unsigned int val) cachep->non_kernel = val; } +unsigned long kmem_cache_get_alloc (struct kmem_cache *cachep) +{ +return cachep->size * cachep->nr_allocated; +} + +unsigned long kmem_cache_nr_allocated (struct kmem_cache *cachep) +{ +return cachep->nr_allocated; +} + +unsigned long kmem_cache_nr_tallocated (struct kmem_cache *cachep) +{ +return cachep->nr_tallocated; +} + +void kmem_cache_zero_nr_tallocated (struct kmem_cache *cachep) +{ + cachep->nr_tallocated =0 ; +} +void *kmem_cache_alloc (struct kmem_cache *cachep,int gfp) {void *p;
@@ -63,7 +85,9 @@ void *kmem_cache_alloc(struct kmem_cache *cachep, int gfp)memset (p,0 , cachep->size); } +uatomic_inc (&cachep->nr_allocated);uatomic_inc (&nr_allocated); +uatomic_inc (&cachep->nr_tallocated);if (kmalloc_verbose)printf ("Allocating %p from slab\n" , p);return p;
@@ -73,6 +97,7 @@ void kmem_cache_free(struct kmem_cache *cachep, void *objp) {assert (objp);uatomic_dec (&nr_allocated); +uatomic_dec (&cachep->nr_allocated);if (kmalloc_verbose)printf ("Freeing %p to slab\n" , objp);pthread_mutex_lock (&cachep->lock);
@@ -124,6 +149,8 @@ kmem_cache_create(const char *name, unsigned int size, unsigned int align, ret->size = size; ret->align = align; ret->nr_objs =0 ; + ret->nr_allocated =0 ; + ret->nr_tallocated =0 ; ret->objs =NULL ; ret->ctor = ctor; ret->non_kernel =0 ;
Signature · 1 line
2.30.2
PATCH v2 4/4 radix tree test suite: Add support for slab bulk APIs
In reply to Liam HowlettAdd support for kmem_cache_free_bulk() and kmem_cache_alloc_bulk() to the radix tree test suite.
--- tools/testing/radix-tree/linux.c | 118 +++++++++++++++++++++++++- tools/testing/radix-tree/linux/slab.h | 4 + 2 files changed, 120 insertions(+), 2 deletions(-)
tools/testing/radix-tree/linux.c +116 -2
@@ -93,14 +93,13 @@ void *kmem_cache_alloc(struct kmem_cache *cachep, int gfp)return p; } -void kmem_cache_free (struct kmem_cache *cachep,void *objp) +void kmem_cache_free_locked (struct kmem_cache *cachep,void *objp) {assert (objp);uatomic_dec (&nr_allocated);uatomic_dec (&cachep->nr_allocated);if (kmalloc_verbose)printf ("Freeing %p to slab\n" , objp); -pthread_mutex_lock (&cachep->lock);if (cachep->nr_objs >10 || cachep->align) {memset (objp,POISON_FREE , cachep->size);free (objp);
@@ -110,9 +109,80 @@ void kmem_cache_free(struct kmem_cache *cachep, void *objp) node->parent = cachep->objs; cachep->objs = node; } +} + +void kmem_cache_free (struct kmem_cache *cachep,void *objp) +{ +pthread_mutex_lock (&cachep->lock); +kmem_cache_free_locked (cachep, objp); +pthread_mutex_unlock (&cachep->lock); +} + +void kmem_cache_free_bulk (struct kmem_cache *cachep,size_t size,void **list) +{ +if (kmalloc_verbose) +pr_debug ("Bulk free %p[0-%lu]\n" , list, size -1 ); + +pthread_mutex_lock (&cachep->lock); +for (int i =0 ; i < size; i++) +kmem_cache_free_locked (cachep, list[i]);pthread_mutex_unlock (&cachep->lock); } +int kmem_cache_alloc_bulk (struct kmem_cache *cachep,gfp_t gfp,size_t size, +void **p) +{ +size_t i; + +if (kmalloc_verbose) +pr_debug ("Bulk alloc %lu\n" , size); + +if (!(gfp & __GFP_DIRECT_RECLAIM)) { +if (cachep->non_kernel < size) +return 0 ; + + cachep->non_kernel -= size; + } + +pthread_mutex_lock (&cachep->lock); +if (cachep->nr_objs >= size) { +struct radix_tree_node *node; + +for (i =0 ; i < size; i++) { + node = cachep->objs; + cachep->nr_objs--; + cachep->objs = node->parent; + p[i] = node; + node->parent =NULL ; + } +pthread_mutex_unlock (&cachep->lock); + }else { +pthread_mutex_unlock (&cachep->lock); +for (i =0 ; i < size; i++) { +if (cachep->align) { +posix_memalign (&p[i], cachep->align, + cachep->size * size); + }else { + p[i] =malloc (cachep->size * size); + } +if (cachep->ctor) + cachep->ctor (p[i]); +else if (gfp & __GFP_ZERO) +memset (p[i],0 , cachep->size); + } + } + +for (i =0 ; i < size; i++) { +uatomic_inc (&nr_allocated); +uatomic_inc (&cachep->nr_allocated); +uatomic_inc (&cachep->nr_tallocated); +if (kmalloc_verbose) +printf ("Allocating %p from slab\n" , p[i]); + } + +return size; +} +void *kmalloc (size_t size,gfp_t gfp) {void *ret;
@@ -156,3 +226,47 @@ kmem_cache_create(const char *name, unsigned int size, unsigned int align, ret->non_kernel =0 ;return ret; } + +/* +* Test the test infrastructure for kem_cache_alloc/free and bulk counterparts. +*/ +void test_kmem_cache_bulk (void ) +{ +int i; +void *list[12 ]; +static struct kmem_cache *test_cache, *test_cache2; + +/* +* Testing the bulk allocators without aligned kmem_cache to force the +* bulk alloc/free to reuse +*/ + test_cache =kmem_cache_create ("test_cache" ,256 ,0 ,SLAB_PANIC ,NULL ); + +for (i =0 ; i <5 ; i++) + list[i] =kmem_cache_alloc (test_cache, __GFP_DIRECT_RECLAIM); + +for (i =0 ; i <5 ; i++) +kmem_cache_free (test_cache, list[i]); +assert (test_cache->nr_objs ==5 ); + +kmem_cache_alloc_bulk (test_cache, __GFP_DIRECT_RECLAIM,5 , list); +kmem_cache_free_bulk (test_cache,5 , list); + +for (i =0 ; i <12 ; i++) + list[i] =kmem_cache_alloc (test_cache, __GFP_DIRECT_RECLAIM); + +for (i =0 ; i <12 ; i++) +kmem_cache_free (test_cache, list[i]); + +/* The last free will not be kept around */ +assert (test_cache->nr_objs ==11 ); + +/* Aligned caches will immediately free */ + test_cache2 =kmem_cache_create ("test_cache2" ,128 ,128 ,SLAB_PANIC ,NULL ); + +kmem_cache_alloc_bulk (test_cache2, __GFP_DIRECT_RECLAIM,10 , list); +kmem_cache_free_bulk (test_cache2,10 , list); +assert (!test_cache2->nr_objs); + + +}
tools/testing/radix-tree/linux/slab.h +4 -0
@@ -24,4 +24,8 @@ struct kmem_cache *kmem_cache_create(const char *name, unsigned int size, unsigned int align, unsigned int flags, void (*ctor)(void *)); +void kmem_cache_free_bulk (struct kmem_cache *cachep,size_t size,void **list); +int kmem_cache_alloc_bulk (struct kmem_cache *cachep,gfp_t gfp,size_t size, +void **list); +#endif /* SLAB_H */
Signature · 1 line
2.30.2