abstract_mem.h

Go to the documentation of this file.

/*
 *
 *
 * Copyright © Linux box Corporation, 2012
 * Author: Adam C. Emerson <aemerson@linuxbox.com>
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 3 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 * ---------------------------------------
 */

#ifndef _ABSTRACT_MEM_H
#define _ABSTRACT_MEM_H

#include <stdlib.h>
#include <string.h>
#include <assert.h>

static inline void *
gsh_malloc(size_t n)
{
     return malloc(n);
}

static inline void *
gsh_malloc_aligned(size_t a, size_t n)
{
    void *p;
    if(posix_memalign(&p, a, n) != 0)
        p = NULL;
    return p;
}

static inline void *
gsh_calloc(size_t s, size_t n)
{
     return calloc(s, n);
}

static inline void *
gsh_realloc(void *p, size_t n)
{
     return realloc(p, n);
}

static inline char *
gsh_strdup(const char *s)
{
     return strdup(s);
}

static inline void
gsh_free(void *p)
{
     free(p);
}

static inline void
gsh_free_size(void *p, size_t n __attribute__((unused)))
{
     free(p);
}

typedef struct pool pool_t;

typedef pool_t*(*pool_initializer_t)(size_t size,
                                     void* param);

typedef void (*pool_destroyer_t)(pool_t *pool);

typedef void *(*pool_allocator_t)(pool_t *pool);

typedef void (*pool_freer_t)(pool_t *pool,
                             void* object);


struct pool_substrate_vector {
     pool_initializer_t initializer; /*< Create an underlying pool */
     pool_destroyer_t destroyer; /*< Destroy an underlying pool */
     pool_allocator_t allocator; /*< Allocate an object */
     pool_freer_t freer; /*< Free an object */
};

typedef void(*pool_constructor_t)(void *object,
                                  void *parameters);

typedef void(*pool_destructor_t)(void *object);

struct pool {
     char *name; /*< The name of the pool */
     size_t object_size; /*< The size of the objects created */
     pool_constructor_t constructor; /*< The object constructor */
     pool_destructor_t destructor; /*< The object destructor */
     struct pool_substrate_vector *substrate_vector; /*< Pool operations */
     char substrate_data[]; /*< The beginning of any substrate-specific
                                data */
};

static inline pool_t*
pool_init(const char* name,
          size_t object_size,
          const struct pool_substrate_vector *substrate,
          void *substrate_params,
          pool_constructor_t constructor,
          pool_destructor_t destructor)
{
     pool_t *pool = substrate->initializer(object_size,
                                           substrate_params);
     if (pool) {
          pool->substrate_vector = (struct pool_substrate_vector *)substrate;
          pool->object_size = object_size;
          pool->constructor = constructor;
          pool->destructor = destructor;
          if (name) {
               pool->name = gsh_strdup(name);
          } else {
               pool->name = NULL;
          }
     }
     return pool;
}

static inline void
pool_destroy(pool_t *pool)
{
     pool->substrate_vector->destroyer(pool);
}

static inline void*
pool_alloc(pool_t *pool, void *parameters)
{
     void *object = pool->substrate_vector->allocator(pool);
     if (object && (pool->constructor)) {
          (pool->constructor)(object, parameters);
     }
     return object;
}

static inline void
pool_free(pool_t *pool, void* object)
{
     if (pool->destructor) {
          (pool->destructor)(object);
     }
     pool->substrate_vector->freer(pool, object);
}

static inline pool_t*
pool_basic_initializer(size_t size __attribute__((unused)),
                       void* param __attribute__((unused)))
{
     assert(param == NULL); /* We take no parameters */
     return gsh_malloc(sizeof(pool_t));
}

static inline void
pool_basic_destroy(pool_t *pool)
{
     gsh_free(pool);
}

static inline void*
pool_basic_alloc(pool_t *pool)
{
     if (pool->constructor) {
          return gsh_malloc(pool->object_size);
     } else {
          return gsh_calloc(1, pool->object_size);
     }
}

static inline void
pool_basic_free(pool_t *pool,
                void* object)
{
     gsh_free(object);
}

static const struct pool_substrate_vector pool_basic_substrate[]= {
     {.initializer = pool_basic_initializer,
      .destroyer = pool_basic_destroy,
      .allocator = pool_basic_alloc,
      .freer = pool_basic_free}
};

#endif /* _ABSTRACT_MEM_H */