Andrew's git - gitweb.git/blob

   1/*
   2 * alloc.c  - specialized allocator for internal objects
   3 *
   4 * Copyright (C) 2006 Linus Torvalds
   5 *
   6 * The standard malloc/free wastes too much space for objects, partly because
   7 * it maintains all the allocation infrastructure, but even more because it ends
   8 * up with maximal alignment because it doesn't know what the object alignment
   9 * for the new allocation is.
  10 */
  11#include "cache.h"
  12#include "object.h"
  13#include "blob.h"
  14#include "tree.h"
  15#include "commit.h"
  16#include "tag.h"
  17#include "alloc.h"
  18
  19#define BLOCKING 1024
  20
  21union any_object {
  22        struct object object;
  23        struct blob blob;
  24        struct tree tree;
  25        struct commit commit;
  26        struct tag tag;
  27};
  28
  29struct alloc_state {
  30        int count; /* total number of nodes allocated */
  31        int nr;    /* number of nodes left in current allocation */
  32        void *p;   /* first free node in current allocation */
  33
  34        /* bookkeeping of allocations */
  35        void **slabs;
  36        int slab_nr, slab_alloc;
  37};
  38
  39void *allocate_alloc_state(void)
  40{
  41        return xcalloc(1, sizeof(struct alloc_state));
  42}
  43
  44void clear_alloc_state(struct alloc_state *s)
  45{
  46        while (s->slab_nr > 0) {
  47                s->slab_nr--;
  48                free(s->slabs[s->slab_nr]);
  49        }
  50
  51        FREE_AND_NULL(s->slabs);
  52}
  53
  54static inline void *alloc_node(struct alloc_state *s, size_t node_size)
  55{
  56        void *ret;
  57
  58        if (!s->nr) {
  59                s->nr = BLOCKING;
  60                s->p = xmalloc(BLOCKING * node_size);
  61
  62                ALLOC_GROW(s->slabs, s->slab_nr + 1, s->slab_alloc);
  63                s->slabs[s->slab_nr++] = s->p;
  64        }
  65        s->nr--;
  66        s->count++;
  67        ret = s->p;
  68        s->p = (char *)s->p + node_size;
  69        memset(ret, 0, node_size);
  70
  71        return ret;
  72}
  73
  74void *alloc_blob_node(struct repository *r)
  75{
  76        struct blob *b = alloc_node(r->parsed_objects->blob_state, sizeof(struct blob));
  77        b->object.type = OBJ_BLOB;
  78        return b;
  79}
  80
  81void *alloc_tree_node(struct repository *r)
  82{
  83        struct tree *t = alloc_node(r->parsed_objects->tree_state, sizeof(struct tree));
  84        t->object.type = OBJ_TREE;
  85        return t;
  86}
  87
  88void *alloc_tag_node(struct repository *r)
  89{
  90        struct tag *t = alloc_node(r->parsed_objects->tag_state, sizeof(struct tag));
  91        t->object.type = OBJ_TAG;
  92        return t;
  93}
  94
  95void *alloc_object_node(struct repository *r)
  96{
  97        struct object *obj = alloc_node(r->parsed_objects->object_state, sizeof(union any_object));
  98        obj->type = OBJ_NONE;
  99        return obj;
 100}
 101
 102unsigned int alloc_commit_index(struct repository *r)
 103{
 104        return r->parsed_objects->commit_count++;
 105}
 106
 107void *alloc_commit_node(struct repository *r)
 108{
 109        struct commit *c = alloc_node(r->parsed_objects->commit_state, sizeof(struct commit));
 110        c->object.type = OBJ_COMMIT;
 111        c->index = alloc_commit_index(r);
 112        return c;
 113}
 114
 115static void report(const char *name, unsigned int count, size_t size)
 116{
 117        fprintf(stderr, "%10s: %8u (%"PRIuMAX" kB)\n",
 118                        name, count, (uintmax_t) size);
 119}
 120
 121#define REPORT(name, type)      \
 122    report(#name, r->parsed_objects->name##_state->count, \
 123                  r->parsed_objects->name##_state->count * sizeof(type) >> 10)
 124
 125void alloc_report(struct repository *r)
 126{
 127        REPORT(blob, struct blob);
 128        REPORT(tree, struct tree);
 129        REPORT(commit, struct commit);
 130        REPORT(tag, struct tag);
 131        REPORT(object, union any_object);
 132}