perf: Remove the xmem_arena allocator
authorBarret Rhoden <brho@cs.berkeley.edu>
Wed, 25 May 2016 15:33:38 +0000 (11:33 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Thu, 16 Jun 2016 15:48:37 +0000 (11:48 -0400)
It might have had a performance benefit, but it cluttered up the code and
forced us to pass memfile pointers around when we shouldn't need to -
specifically to mem_block_alloc().

The only thing that was called a lot was mem_block_alloc(), which now is
just a malloc under the hood, and the only existing time it was used was in
mem_file_write(), which already attempted to avoid malloc calls.

Now I can call mem_block_alloc() without worrying about the memfile.

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
tools/profile/perf/perfconv.c
tools/profile/perf/perfconv.h
tools/profile/perf/xlib.c
tools/profile/perf/xlib.h

index 7bed726..d6f34ea 100644 (file)
@@ -91,10 +91,9 @@ static int read_record(FILE *file, struct perf_record *pr)
        return 0;
 }
 
-static struct mem_block *mem_block_alloc(struct mem_file *mf, size_t size)
+static struct mem_block *mem_block_alloc(size_t size)
 {
-       struct mem_block *mb = xmem_arena_alloc(mf->ma,
-                                                                                       sizeof(struct mem_block) + size);
+       struct mem_block *mb = xmalloc(sizeof(struct mem_block) + size);
 
        mb->next = NULL;
        mb->base = mb->wptr = (char *) mb + sizeof(struct mem_block);
@@ -116,10 +115,9 @@ static char *mem_block_write(struct mem_block *mb, const void *data,
        return wrbase;
 }
 
-static void mem_file_init(struct mem_file *mf, struct mem_arena *ma)
+static void mem_file_init(struct mem_file *mf)
 {
        ZERO_DATA(*mf);
-       mf->ma = ma;
 }
 
 static int mem_block_can_write(struct mem_block *mb, size_t size, int flags)
@@ -139,7 +137,7 @@ static void *mem_file_write(struct mem_file *mf, const void *data, size_t size,
                struct mem_block *mb = mf->tail;
 
                if (!mb || !mem_block_can_write(mb, size, flags)) {
-                       mb = mem_block_alloc(mf, max(MEMFILE_BLOCK_SIZE, size));
+                       mb = mem_block_alloc(max(MEMFILE_BLOCK_SIZE, size));
                        if (!mf->tail)
                                mf->head = mb;
                        else
@@ -179,8 +177,7 @@ static void mem_file_sync(struct mem_file *mf, FILE *file, uint64_t rel_offset)
 static struct mem_file_reloc *mem_file_add_reloc(struct mem_file *mf,
                                                                                                 uint64_t *ptr)
 {
-       struct mem_file_reloc *rel =
-               xmem_arena_zalloc(mf->ma, sizeof(struct mem_file_reloc));
+       struct mem_file_reloc *rel = xzmalloc(sizeof(struct mem_file_reloc));
 
        rel->ptr = ptr;
        rel->next = mf->relocs;
@@ -194,7 +191,7 @@ void perfconv_add_kernel_mmap(struct perfconv_context *cctx)
        char path[] = "[kernel.kallsyms]";
        struct static_mmap64 *mm;
 
-       mm = xmem_arena_zalloc(&cctx->ma, sizeof(struct static_mmap64));
+       mm = xzmalloc(sizeof(struct static_mmap64));
        mm->pid = -1;                           /* Linux HOST_KERNEL_ID == -1 */
        mm->tid = 0;                            /* Default thread: swapper */
        mm->header_misc = PERF_RECORD_MISC_KERNEL;
@@ -206,7 +203,7 @@ void perfconv_add_kernel_mmap(struct perfconv_context *cctx)
        mm->addr = 0;
        mm->size = 0xffffffffffffffff;
        mm->offset = 0x0;
-       mm->path = xmem_arena_strdup(&cctx->ma, path);
+       mm->path = xstrdup(path);
 
        mm->next = cctx->static_mmaps;
        cctx->static_mmaps = mm;
@@ -494,25 +491,22 @@ struct perfconv_context *perfconv_create_context(struct perf_context *pctx)
        struct perfconv_context *cctx = xzmalloc(sizeof(struct perfconv_context));
 
        cctx->pctx = pctx;
-       xmem_arena_init(&cctx->ma, 0);
        perf_header_init(&cctx->ph);
        headers_init(&cctx->hdrs);
-       mem_file_init(&cctx->fhdrs, &cctx->ma);
-       mem_file_init(&cctx->attr_ids, &cctx->ma);
-       mem_file_init(&cctx->attrs, &cctx->ma);
-       mem_file_init(&cctx->data, &cctx->ma);
+       mem_file_init(&cctx->fhdrs);
+       mem_file_init(&cctx->attr_ids);
+       mem_file_init(&cctx->attrs);
+       mem_file_init(&cctx->data);
        /* event_types is ignored in newer versions of perf */
-       mem_file_init(&cctx->event_types, &cctx->ma);
+       mem_file_init(&cctx->event_types);
 
        return cctx;
 }
 
 void perfconv_free_context(struct perfconv_context *cctx)
 {
-       if (cctx) {
-               xmem_arena_destroy(&cctx->ma);
+       if (cctx)
                free(cctx);
-       }
 }
 
 void perfconv_process_input(struct perfconv_context *cctx, FILE *input,
index ec54e40..2b7929b 100644 (file)
@@ -32,7 +32,6 @@ struct mem_block {
 };
 
 struct mem_file {
-       struct mem_arena *ma;
        size_t size;
        struct mem_block *head;
        struct mem_block *tail;
@@ -61,7 +60,6 @@ struct perf_event_id {
 
 struct perfconv_context {
        struct perf_context *pctx;
-       struct mem_arena ma;
        int debug_level;
        struct static_mmap64 *static_mmaps;
        struct perf_header ph;
index 419d483..6281695 100644 (file)
 #include <errno.h>
 #include "xlib.h"
 
-void xmem_arena_init(struct mem_arena *ma, size_t block_size)
-{
-       memset(ma, 0, sizeof(*ma));
-       ma->block_size = (block_size != 0) ? block_size : (128 * 1024);
-}
-
-void xmem_arena_destroy(struct mem_arena *ma)
-{
-       struct mem_arena_block *tmp;
-
-       while ((tmp = ma->blocks) != NULL) {
-               ma->blocks = tmp->next;
-               free(tmp);
-       }
-}
-
-void *xmem_arena_alloc(struct mem_arena *ma, size_t size)
-{
-       size_t aspace = ma->top - ma->ptr;
-       void *data;
-
-       size = ROUNDUP(size, sizeof(void *));
-       if (aspace < size) {
-               size_t bsize;
-               struct mem_arena_block *blk;
-
-               /* If there is enough space left, and the requested size is big enough,
-                * hand over full block and keep the leftover space as is.
-                */
-               if (aspace >= (ma->block_size / 8)) {
-                       blk = xmalloc(size + sizeof(struct mem_arena_block));
-                       blk->next = ma->blocks;
-                       ma->blocks = blk;
-
-                       return (char *) blk + sizeof(struct mem_arena_block);
-               }
-
-               bsize = max(ma->block_size, size) + sizeof(struct mem_arena_block);
-               blk = xmalloc(bsize);
-
-               blk->next = ma->blocks;
-               ma->blocks = blk;
-               ma->ptr = (char *) blk + sizeof(struct mem_arena_block);
-               ma->top = ma->ptr + bsize;
-       }
-       data = ma->ptr;
-       ma->ptr += size;
-
-       return data;
-}
-
-void *xmem_arena_zalloc(struct mem_arena *ma, size_t size)
-{
-       void *data = xmem_arena_alloc(ma, size);
-
-       memset(data, 0, size);
-
-       return data;
-}
-
-char *xmem_arena_strdup(struct mem_arena *ma, const char *str)
-{
-       size_t size = strlen(str);
-       char *dstr = xmem_arena_alloc(ma, size + 1);
-
-       memcpy(dstr, str, size + 1);
-
-       return dstr;
-}
-
 int xopen(const char *path, int flags, mode_t mode)
 {
        int fd = open(path, flags, mode);
index 5421f67..ade4635 100644 (file)
                                        __FILE__, __LINE__);                                                            \
        } while (0)
 
-struct mem_arena_block {
-       struct mem_arena_block *next;
-};
-
-struct mem_arena {
-       size_t block_size;
-       struct mem_arena_block *blocks;
-       char *ptr;
-       char *top;
-};
-
-void xmem_arena_init(struct mem_arena *ma, size_t block_size);
-void xmem_arena_destroy(struct mem_arena *ma);
-void *xmem_arena_alloc(struct mem_arena *ma, size_t size);
-void *xmem_arena_zalloc(struct mem_arena *ma, size_t size);
-char *xmem_arena_strdup(struct mem_arena *ma, const char *str);
 int xopen(const char *path, int flags, mode_t mode);
 void xwrite(int fd, const void *data, size_t size);
 void xread(int fd, void *data, size_t size);