libpurple/memorypool.c

   1 /*
   2  * Purple
   3  *
   4  * Purple is the legal property of its developers, whose names are too
   5  * numerous to list here. Please refer to the COPYRIGHT file distributed
   6  * with this source distribution
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or (at
  11  * your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
  21  */
  22
  23 #include "memorypool.h"
  24
  25 #include <string.h>
  26
  27 #define PURPLE_MEMORY_POOL_BLOCK_PADDING (sizeof(guint64))
  28 #define PURPLE_MEMORY_POINTER_SHIFT(pointer, value) \
  29         (gpointer)((guintptr)(pointer) + (value))
  30 #define PURPLE_MEMORY_PADDED(pointer, padding) \
  31         (gpointer)((((guintptr)(pointer) - 1) / (padding) + 1) * padding)
  32
  33 #define PURPLE_MEMORY_POOL_DEFAULT_BLOCK_SIZE 1024
  34 #define PURPLE_MEMORY_POOL_DISABLED FALSE
  35
  36 typedef struct _PurpleMemoryPoolBlock PurpleMemoryPoolBlock;
  37
  38 typedef struct
  39 {
  40         gboolean disabled;
  41         gulong block_size;
  42
  43         PurpleMemoryPoolBlock *first_block;
  44         PurpleMemoryPoolBlock *last_block;
  45 } PurpleMemoryPoolPrivate;
  46
  47 struct _PurpleMemoryPoolBlock
  48 {
  49         gpointer available_ptr;
  50         gpointer end_ptr;
  51         PurpleMemoryPoolBlock *next;
  52 };
  53
  54 enum
  55 {
  56         PROP_ZERO,
  57         PROP_BLOCK_SIZE,
  58         PROP_LAST
  59 };
  60
  61 static GParamSpec *properties[PROP_LAST];
  62
  63 G_DEFINE_TYPE_WITH_PRIVATE(PurpleMemoryPool, purple_memory_pool,
  64                 G_TYPE_OBJECT);
  65
  66 /*******************************************************************************
  67  * Memory allocation/deallocation
  68  ******************************************************************************/
  69
  70 static PurpleMemoryPoolBlock *
  71 purple_memory_pool_block_new(gulong block_size)
  72 {
  73         gpointer block_raw;
  74         PurpleMemoryPoolBlock *block;
  75         gsize total_size;
  76
  77         /* ceil block struct size to the multipy of align */
  78         total_size = ((sizeof(PurpleMemoryPoolBlock) - 1) /
  79                 PURPLE_MEMORY_POOL_BLOCK_PADDING + 1) *
  80                 sizeof(PurpleMemoryPoolBlock);
  81         g_return_val_if_fail(block_size < G_MAXSIZE - total_size, NULL);
  82         total_size += block_size;
  83
  84         block_raw = g_try_malloc(total_size);
  85         g_return_val_if_fail(block_raw != NULL, NULL);
  86         block = block_raw;
  87
  88         /* in fact, we don't set available_ptr padded to
  89          * PURPLE_MEMORY_POOL_BLOCK_PADDING, but we guarantee, there is at least
  90          * block_size long block if padded to that value. */
  91         block->available_ptr = PURPLE_MEMORY_POINTER_SHIFT(block_raw,
  92                 sizeof(PurpleMemoryPoolBlock));
  93         block->end_ptr = PURPLE_MEMORY_POINTER_SHIFT(block_raw, total_size);
  94         block->next = NULL;
  95
  96         return block;
  97 }
  98
  99 static gpointer
 100 purple_memory_pool_alloc_impl(PurpleMemoryPool *pool, gsize size, guint alignment)
 101 {
 102         PurpleMemoryPoolPrivate *priv = NULL;
 103         PurpleMemoryPoolBlock *blk;
 104         gpointer mem = NULL;
 105
 106         g_return_val_if_fail(PURPLE_IS_MEMORY_POOL(pool), NULL);
 107
 108         priv = purple_memory_pool_get_instance_private(pool);
 109
 110         if (priv->disabled) {
 111                 /* XXX: this may cause some leaks */
 112                 return g_try_malloc(size);
 113         }
 114
 115         g_return_val_if_fail(alignment <= PURPLE_MEMORY_POOL_BLOCK_PADDING, NULL);
 116         g_warn_if_fail(alignment >= 1);
 117         if (alignment < 1)
 118                 alignment = 1;
 119
 120         blk = priv->last_block;
 121
 122         if (blk) {
 123                 mem = PURPLE_MEMORY_PADDED(blk->available_ptr, alignment);
 124                 if (mem >= blk->end_ptr)
 125                         mem = NULL;
 126                 else if (mem < blk->available_ptr) /* gpointer overflow */
 127                         mem = NULL;
 128                 else if (PURPLE_MEMORY_POINTER_SHIFT(mem, size) >= blk->end_ptr)
 129                         mem = NULL;
 130         }
 131
 132         if (mem == NULL) {
 133                 gsize real_size = priv->block_size;
 134                 if (real_size < size)
 135                         real_size = size;
 136                 blk = purple_memory_pool_block_new(real_size);
 137                 g_return_val_if_fail(blk != NULL, NULL);
 138
 139                 g_assert((priv->first_block == NULL) ==
 140                         (priv->last_block == NULL));
 141
 142                 if (priv->first_block == NULL) {
 143                         priv->first_block = blk;
 144                         priv->last_block = blk;
 145                 } else {
 146                         priv->last_block->next = blk;
 147                         priv->last_block = blk;
 148                 }
 149
 150                 mem = PURPLE_MEMORY_PADDED(blk->available_ptr, alignment);
 151                 g_assert((guintptr)mem + size < (guintptr)blk->end_ptr);
 152                 g_assert(mem >= blk->available_ptr); /* gpointer overflow */
 153         }
 154
 155         g_assert(blk != NULL);
 156         g_assert(mem != NULL);
 157
 158         blk->available_ptr = PURPLE_MEMORY_POINTER_SHIFT(mem, size);
 159         g_assert(blk->available_ptr <= blk->end_ptr);
 160
 161         return mem;
 162 }
 163
 164 static void
 165 purple_memory_pool_cleanup_impl(PurpleMemoryPool *pool)
 166 {
 167         PurpleMemoryPoolPrivate *priv =
 168                         purple_memory_pool_get_instance_private(pool);
 169         PurpleMemoryPoolBlock *blk;
 170
 171         blk = priv->first_block;
 172         priv->first_block = NULL;
 173         priv->last_block = NULL;
 174         while (blk) {
 175                 PurpleMemoryPoolBlock *next = blk->next;
 176                 g_free(blk);
 177                 blk = next;
 178         }
 179 }
 180
 181
 182 /*******************************************************************************
 183  * API implementation
 184  ******************************************************************************/
 185
 186 void
 187 purple_memory_pool_set_block_size(PurpleMemoryPool *pool, gulong block_size)
 188 {
 189         PurpleMemoryPoolPrivate *priv = NULL;
 190
 191         g_return_if_fail(PURPLE_IS_MEMORY_POOL(pool));
 192
 193         priv = purple_memory_pool_get_instance_private(pool);
 194         priv->block_size = block_size;
 195         g_object_notify_by_pspec(G_OBJECT(pool), properties[PROP_BLOCK_SIZE]);
 196 }
 197
 198 gpointer
 199 purple_memory_pool_alloc(PurpleMemoryPool *pool, gsize size, guint alignment)
 200 {
 201         PurpleMemoryPoolClass *klass;
 202
 203         if (size == 0)
 204                 return NULL;
 205
 206         g_return_val_if_fail(PURPLE_IS_MEMORY_POOL(pool), NULL);
 207
 208         klass = PURPLE_MEMORY_POOL_GET_CLASS(pool);
 209         g_return_val_if_fail(klass != NULL, NULL);
 210         g_return_val_if_fail(klass->palloc != NULL, NULL);
 211
 212         return klass->palloc(pool, size, alignment);
 213 }
 214
 215 gpointer
 216 purple_memory_pool_alloc0(PurpleMemoryPool *pool, gsize size, guint alignment)
 217 {
 218         gpointer mem;
 219
 220         if (size == 0)
 221                 return NULL;
 222
 223         mem = purple_memory_pool_alloc(pool, size, alignment);
 224         g_return_val_if_fail(mem != NULL, NULL);
 225
 226         memset(mem, 0, size);
 227
 228         return mem;
 229 }
 230
 231 void
 232 purple_memory_pool_free(PurpleMemoryPool *pool, gpointer mem)
 233 {
 234         PurpleMemoryPoolClass *klass;
 235
 236         if (mem == NULL)
 237                 return;
 238
 239         g_return_if_fail(PURPLE_IS_MEMORY_POOL(pool));
 240
 241         klass = PURPLE_MEMORY_POOL_GET_CLASS(pool);
 242         g_return_if_fail(klass != NULL);
 243
 244         if (klass->pfree)
 245                 klass->pfree(pool, mem);
 246 }
 247
 248 void
 249 purple_memory_pool_cleanup(PurpleMemoryPool *pool)
 250 {
 251         PurpleMemoryPoolClass *klass;
 252
 253         g_return_if_fail(PURPLE_IS_MEMORY_POOL(pool));
 254
 255         klass = PURPLE_MEMORY_POOL_GET_CLASS(pool);
 256         g_return_if_fail(klass != NULL);
 257
 258         klass->cleanup(pool);
 259 }
 260
 261
 262 /*******************************************************************************
 263  * Object stuff
 264  ******************************************************************************/
 265
 266 PurpleMemoryPool *
 267 purple_memory_pool_new(void)
 268 {
 269         return g_object_new(PURPLE_TYPE_MEMORY_POOL, NULL);
 270 }
 271
 272 static void
 273 purple_memory_pool_init(PurpleMemoryPool *pool)
 274 {
 275         PurpleMemoryPoolPrivate *priv =
 276                         purple_memory_pool_get_instance_private(pool);
 277
 278         priv->disabled = PURPLE_MEMORY_POOL_DISABLED;
 279 }
 280
 281 static void
 282 purple_memory_pool_finalize(GObject *obj)
 283 {
 284         purple_memory_pool_cleanup(PURPLE_MEMORY_POOL(obj));
 285
 286         G_OBJECT_CLASS(purple_memory_pool_parent_class)->finalize(obj);
 287 }
 288
 289 static void
 290 purple_memory_pool_get_property(GObject *obj, guint param_id, GValue *value,
 291         GParamSpec *pspec)
 292 {
 293         PurpleMemoryPool *pool = PURPLE_MEMORY_POOL(obj);
 294         PurpleMemoryPoolPrivate *priv =
 295                         purple_memory_pool_get_instance_private(pool);
 296
 297         switch (param_id) {
 298                 case PROP_BLOCK_SIZE:
 299                         g_value_set_ulong(value, priv->block_size);
 300                         break;
 301                 default:
 302                         G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
 303         }
 304 }
 305
 306 static void
 307 purple_memory_pool_set_property(GObject *obj, guint param_id,
 308         const GValue *value, GParamSpec *pspec)
 309 {
 310         PurpleMemoryPool *pool = PURPLE_MEMORY_POOL(obj);
 311         PurpleMemoryPoolPrivate *priv =
 312                         purple_memory_pool_get_instance_private(pool);
 313
 314         switch (param_id) {
 315                 case PROP_BLOCK_SIZE:
 316                         priv->block_size = g_value_get_ulong(value);
 317                         break;
 318                 default:
 319                         G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
 320         }
 321 }
 322
 323 static void
 324 purple_memory_pool_class_init(PurpleMemoryPoolClass *klass)
 325 {
 326         GObjectClass *obj_class = G_OBJECT_CLASS(klass);
 327
 328         obj_class->finalize = purple_memory_pool_finalize;
 329         obj_class->get_property = purple_memory_pool_get_property;
 330         obj_class->set_property = purple_memory_pool_set_property;
 331
 332         klass->palloc = purple_memory_pool_alloc_impl;
 333         klass->cleanup = purple_memory_pool_cleanup_impl;
 334
 335         properties[PROP_BLOCK_SIZE] = g_param_spec_ulong("block-size",
 336                 "Block size", "The default size of each block of pool memory.",
 337                 0, G_MAXULONG, PURPLE_MEMORY_POOL_DEFAULT_BLOCK_SIZE,
 338                 G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);
 339
 340         g_object_class_install_properties(obj_class, PROP_LAST, properties);
 341 }
 342
 343 gchar *
 344 purple_memory_pool_strdup(PurpleMemoryPool *pool, const gchar *str)
 345 {
 346         gsize str_len;
 347         gchar *str_dup;
 348
 349         if (str == NULL)
 350                 return NULL;
 351
 352         g_return_val_if_fail(PURPLE_IS_MEMORY_POOL(pool), NULL);
 353
 354         str_len = strlen(str);
 355         str_dup = purple_memory_pool_alloc(pool, str_len + 1, sizeof(gchar));
 356         g_return_val_if_fail(str_dup != NULL, NULL);
 357
 358         memcpy(str_dup, str, str_len);
 359         str_dup[str_len] = '\0';
 360
 361         return str_dup;
 362 }