X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gmem.c;h=bc0f92385491e1bc8601b0be39f0279fd6b41a2d;hb=32ef70d4b27ac912188a47b6611d5e8c0516cc2f;hp=70444a840dfe00e7bcc660e3895098ee31f75501;hpb=1c3646f597009f2c7218cded888e7b6b0c5f3146;p=platform%2Fupstream%2Fglib.git diff --git a/gmem.c b/gmem.c index 70444a8..bc0f923 100644 --- a/gmem.c +++ b/gmem.c @@ -2,20 +2,36 @@ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald * * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Library General Public + * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library 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 - * Library General Public License for more details. + * Lesser General Public License for more details. * - * You should have received a copy of the GNU Library General Public + * 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., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ + +/* + * Modified by the GLib Team and others 1997-2000. See the AUTHORS + * file for a list of people on the GLib Team. See the ChangeLog + * files for a list of changes. These files are distributed with + * GLib at ftp://ftp.gtk.org/pub/gtk/. + */ + +/* + * MT safe + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include #include "glib.h" @@ -23,17 +39,38 @@ /* #define ENABLE_MEM_PROFILE */ /* #define ENABLE_MEM_PROFILE_EXCLUDES_MEM_CHUNKS */ /* #define ENABLE_MEM_CHECK */ +#define MEM_PROFILE_TABLE_SIZE 8192 + +/* + * This library can check for some attempts to do illegal things to + * memory (ENABLE_MEM_CHECK), and can do profiling + * (ENABLE_MEM_PROFILE). Both features are implemented by storing + * words before the start of the memory chunk. + * + * The first, at offset -2*SIZEOF_LONG, is used only if + * ENABLE_MEM_CHECK is set, and stores 0 after the memory has been + * allocated and 1 when it has been freed. The second, at offset + * -SIZEOF_LONG, is used if either flag is set and stores the size of + * the block. + * + * The MEM_CHECK flag is checked when memory is realloc'd and free'd, + * and it can be explicitly checked before using a block by calling + * g_mem_check(). + */ #if defined(ENABLE_MEM_PROFILE) && defined(ENABLE_MEM_PROFILE_EXCLUDES_MEM_CHUNKS) -#define ENTER_MEM_CHUNK_ROUTINE() allocating_for_mem_chunk++ -#define LEAVE_MEM_CHUNK_ROUTINE() allocating_for_mem_chunk-- +#define ENTER_MEM_CHUNK_ROUTINE() \ + g_private_set (allocating_for_mem_chunk, \ + g_private_get (allocating_for_mem_chunk) + 1) +#define LEAVE_MEM_CHUNK_ROUTINE() \ + g_private_set (allocating_for_mem_chunk, \ + g_private_get (allocating_for_mem_chunk) - 1) #else #define ENTER_MEM_CHUNK_ROUTINE() #define LEAVE_MEM_CHUNK_ROUTINE() #endif -#define MAX_MEM_AREA 65536L #define MEM_AREA_SIZE 4L #if SIZEOF_VOID_P > SIZEOF_LONG @@ -87,20 +124,27 @@ struct _GRealMemChunk }; -static gulong g_mem_chunk_compute_size (gulong size); +static gulong g_mem_chunk_compute_size (gulong size, + gulong min_size) G_GNUC_CONST; static gint g_mem_chunk_area_compare (GMemArea *a, GMemArea *b); static gint g_mem_chunk_area_search (GMemArea *a, gchar *addr); +/* here we can't use StaticMutexes, as they depend upon a working + * g_malloc, the same holds true for StaticPrivate */ +static GMutex* mem_chunks_lock = NULL; static GRealMemChunk *mem_chunks = NULL; #ifdef ENABLE_MEM_PROFILE -static gulong allocations[4096] = { 0 }; +static GMutex* mem_profile_lock; +static gulong allocations[MEM_PROFILE_TABLE_SIZE] = { 0 }; static gulong allocated_mem = 0; static gulong freed_mem = 0; -static gint allocating_for_mem_chunk = 0; +static GPrivate* allocating_for_mem_chunk = NULL; +#define IS_IN_MEM_CHUNK_ROUTINE() \ + GPOINTER_TO_UINT (g_private_get (allocating_for_mem_chunk)) #endif /* ENABLE_MEM_PROFILE */ @@ -151,17 +195,19 @@ g_malloc (gulong size) *t = size; #ifdef ENABLE_MEM_PROFILE -#ifdef ENABLE_MEM_PROFILE_EXCLUDES_MEM_CHUNKS - if(!allocating_for_mem_chunk) { -#endif - if (size <= 4095) + g_mutex_lock (mem_profile_lock); +# ifdef ENABLE_MEM_PROFILE_EXCLUDES_MEM_CHUNKS + if(!IS_IN_MEM_CHUNK_ROUTINE()) { +# endif + if (size <= MEM_PROFILE_TABLE_SIZE - 1) allocations[size-1] += 1; else - allocations[4095] += 1; + allocations[MEM_PROFILE_TABLE_SIZE - 1] += 1; allocated_mem += size; -#ifdef ENABLE_MEM_PROFILE_EXCLUDES_MEM_CHUNKS +# ifdef ENABLE_MEM_PROFILE_EXCLUDES_MEM_CHUNKS } -#endif +# endif + g_mutex_unlock (mem_profile_lock); #endif /* ENABLE_MEM_PROFILE */ #endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */ @@ -184,9 +230,9 @@ g_malloc0 (gulong size) return NULL; -#ifdef ENABLE_MEM_PROFILE +#if defined (ENABLE_MEM_PROFILE) || defined (ENABLE_MEM_CHECK) size += SIZEOF_LONG; -#endif /* ENABLE_MEM_PROFILE */ +#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */ #ifdef ENABLE_MEM_CHECK size += SIZEOF_LONG; @@ -213,20 +259,22 @@ g_malloc0 (gulong size) p = ((guchar*) p + SIZEOF_LONG); *t = size; -#ifdef ENABLE_MEM_PROFILE -#ifdef ENABLE_MEM_PROFILE_EXCLUDES_MEM_CHUNKS - if(!allocating_for_mem_chunk) { -#endif - if (size <= 4095) +# ifdef ENABLE_MEM_PROFILE + g_mutex_lock (mem_profile_lock); +# ifdef ENABLE_MEM_PROFILE_EXCLUDES_MEM_CHUNKS + if(!IS_IN_MEM_CHUNK_ROUTINE()) { +# endif + if (size <= (MEM_PROFILE_TABLE_SIZE - 1)) allocations[size-1] += 1; else - allocations[4095] += 1; + allocations[MEM_PROFILE_TABLE_SIZE - 1] += 1; allocated_mem += size; -#ifdef ENABLE_MEM_PROFILE_EXCLUDES_MEM_CHUNKS +# ifdef ENABLE_MEM_PROFILE_EXCLUDES_MEM_CHUNKS } -#endif -#endif /* ENABLE_MEM_PROFILE */ -#endif /* ENABLE_MEM_PROFILE */ +# endif + g_mutex_unlock (mem_profile_lock); +# endif /* ENABLE_MEM_PROFILE */ +#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */ return p; @@ -244,7 +292,11 @@ g_realloc (gpointer mem, if (size == 0) - return NULL; + { + g_free (mem); + + return NULL; + } #if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK) @@ -257,13 +309,21 @@ g_realloc (gpointer mem, if (!mem) - p = (gpointer) malloc (size); + { +#ifdef REALLOC_0_WORKS + p = (gpointer) realloc (NULL, size); +#else /* !REALLOC_0_WORKS */ + p = (gpointer) malloc (size); +#endif /* !REALLOC_0_WORKS */ + } else { #if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK) t = (gulong*) ((guchar*) mem - SIZEOF_LONG); #ifdef ENABLE_MEM_PROFILE + g_mutex_lock (mem_profile_lock); freed_mem += *t; + g_mutex_unlock (mem_profile_lock); #endif /* ENABLE_MEM_PROFILE */ mem = t; #endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */ @@ -279,7 +339,7 @@ g_realloc (gpointer mem, } if (!p) - g_error ("could not reallocate %ld bytes", size); + g_error ("could not reallocate %lu bytes", (gulong) size); #ifdef ENABLE_MEM_CHECK @@ -298,17 +358,19 @@ g_realloc (gpointer mem, *t = size; #ifdef ENABLE_MEM_PROFILE + g_mutex_lock (mem_profile_lock); #ifdef ENABLE_MEM_PROFILE_EXCLUDES_MEM_CHUNKS - if(!allocating_for_mem_chunk) { + if(!IS_IN_MEM_CHUNK_ROUTINE()) { #endif - if (size <= 4095) + if (size <= (MEM_PROFILE_TABLE_SIZE - 1)) allocations[size-1] += 1; else - allocations[4095] += 1; + allocations[MEM_PROFILE_TABLE_SIZE - 1] += 1; allocated_mem += size; #ifdef ENABLE_MEM_PROFILE_EXCLUDES_MEM_CHUNKS } #endif + g_mutex_unlock (mem_profile_lock); #endif /* ENABLE_MEM_PROFILE */ #endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */ @@ -329,8 +391,10 @@ g_free (gpointer mem) #if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK) t = (gulong*) ((guchar*) mem - SIZEOF_LONG); size = *t; -#ifdef ENABLE_MEM_PROFILE +#ifdef ENABLE_MEM_PROFILE + g_mutex_lock (mem_profile_lock); freed_mem += size; + g_mutex_unlock (mem_profile_lock); #endif /* ENABLE_MEM_PROFILE */ mem = t; #endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */ @@ -338,11 +402,11 @@ g_free (gpointer mem) #ifdef ENABLE_MEM_CHECK t = (gulong*) ((guchar*) mem - SIZEOF_LONG); if (*t >= 1) - g_warning ("freeing previously freed memory\n"); + g_warning ("freeing previously freed (%lu times) memory\n", *t); *t += 1; mem = t; - memset ((guchar*) mem + 8, 0, size); + memset ((guchar*) mem + 2 * SIZEOF_LONG, 0, size); #else /* ENABLE_MEM_CHECK */ free (mem); #endif /* ENABLE_MEM_CHECK */ @@ -357,18 +421,29 @@ g_mem_profile (void) { #ifdef ENABLE_MEM_PROFILE gint i; - - for (i = 0; i < 4095; i++) - if (allocations[i] > 0) + gulong local_allocations[MEM_PROFILE_TABLE_SIZE]; + gulong local_allocated_mem; + gulong local_freed_mem; + + g_mutex_lock (mem_profile_lock); + for (i = 0; i < MEM_PROFILE_TABLE_SIZE; i++) + local_allocations[i] = allocations[i]; + local_allocated_mem = allocated_mem; + local_freed_mem = freed_mem; + g_mutex_unlock (mem_profile_lock); + + for (i = 0; i < (MEM_PROFILE_TABLE_SIZE - 1); i++) + if (local_allocations[i] > 0) g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, - "%lu allocations of %d bytes\n", allocations[i], i + 1); + "%lu allocations of %d bytes", local_allocations[i], i + 1); - if (allocations[4095] > 0) + if (local_allocations[MEM_PROFILE_TABLE_SIZE - 1] > 0) g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, - "%lu allocations of greater than 4095 bytes\n", allocations[4095]); - g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%lu bytes allocated\n", allocated_mem); - g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%lu bytes freed\n", freed_mem); - g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%lu bytes in use\n", allocated_mem - freed_mem); + "%lu allocations of greater than %d bytes", + local_allocations[MEM_PROFILE_TABLE_SIZE - 1], MEM_PROFILE_TABLE_SIZE - 1); + g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%lu bytes allocated", local_allocated_mem); + g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%lu bytes freed", local_freed_mem); + g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%lu bytes in use", local_allocated_mem - local_freed_mem); #endif /* ENABLE_MEM_PROFILE */ } @@ -381,7 +456,7 @@ g_mem_check (gpointer mem) t = (gulong*) ((guchar*) mem - SIZEOF_LONG - SIZEOF_LONG); if (*t >= 1) - g_warning ("mem: 0x%08x has been freed: %lu\n", (gulong) mem, *t); + g_warning ("mem: 0x%08lx has been freed %lu times\n", (gulong) mem, *t); #endif /* ENABLE_MEM_CHECK */ } @@ -394,8 +469,14 @@ g_mem_chunk_new (gchar *name, GRealMemChunk *mem_chunk; gulong rarea_size; + g_return_val_if_fail (atom_size > 0, NULL); + g_return_val_if_fail (area_size >= atom_size, NULL); + ENTER_MEM_CHUNK_ROUTINE(); + area_size = (area_size + atom_size - 1) / atom_size; + area_size *= atom_size; + mem_chunk = g_new (struct _GRealMemChunk, 1); mem_chunk->name = name; mem_chunk->type = type; @@ -413,34 +494,18 @@ g_mem_chunk_new (gchar *name, if (mem_chunk->atom_size % MEM_ALIGN) mem_chunk->atom_size += MEM_ALIGN - (mem_chunk->atom_size % MEM_ALIGN); - - mem_chunk->area_size = area_size; - if (mem_chunk->area_size > MAX_MEM_AREA) - mem_chunk->area_size = MAX_MEM_AREA; - while (mem_chunk->area_size < mem_chunk->atom_size) - mem_chunk->area_size *= 2; - - rarea_size = mem_chunk->area_size + sizeof (GMemArea) - MEM_AREA_SIZE; - rarea_size = g_mem_chunk_compute_size (rarea_size); + + rarea_size = area_size + sizeof (GMemArea) - MEM_AREA_SIZE; + rarea_size = g_mem_chunk_compute_size (rarea_size, atom_size + sizeof (GMemArea) - MEM_AREA_SIZE); mem_chunk->area_size = rarea_size - (sizeof (GMemArea) - MEM_AREA_SIZE); - - /* - mem_chunk->area_size -= (sizeof (GMemArea) - MEM_AREA_SIZE); - if (mem_chunk->area_size < mem_chunk->atom_size) - { - mem_chunk->area_size = (mem_chunk->area_size + sizeof (GMemArea) - MEM_AREA_SIZE) * 2; - mem_chunk->area_size -= (sizeof (GMemArea) - MEM_AREA_SIZE); - } - - if (mem_chunk->area_size % mem_chunk->atom_size) - mem_chunk->area_size += mem_chunk->atom_size - (mem_chunk->area_size % mem_chunk->atom_size); - */ - + + g_mutex_lock (mem_chunks_lock); mem_chunk->next = mem_chunks; mem_chunk->prev = NULL; if (mem_chunks) mem_chunks->prev = mem_chunk; mem_chunks = mem_chunk; + g_mutex_unlock (mem_chunks_lock); LEAVE_MEM_CHUNK_ROUTINE(); @@ -454,7 +519,7 @@ g_mem_chunk_destroy (GMemChunk *mem_chunk) GMemArea *mem_areas; GMemArea *temp_area; - g_assert (mem_chunk != NULL); + g_return_if_fail (mem_chunk != NULL); ENTER_MEM_CHUNK_ROUTINE(); @@ -473,8 +538,10 @@ g_mem_chunk_destroy (GMemChunk *mem_chunk) if (rmem_chunk->prev) rmem_chunk->prev->next = rmem_chunk->next; + g_mutex_lock (mem_chunks_lock); if (rmem_chunk == mem_chunks) mem_chunks = mem_chunks->next; + g_mutex_unlock (mem_chunks_lock); if (rmem_chunk->type == G_ALLOC_AND_FREE) g_tree_destroy (rmem_chunk->mem_tree); @@ -493,7 +560,7 @@ g_mem_chunk_alloc (GMemChunk *mem_chunk) ENTER_MEM_CHUNK_ROUTINE(); - g_assert (mem_chunk != NULL); + g_return_val_if_fail (mem_chunk != NULL, NULL); rmem_chunk = (GRealMemChunk*) mem_chunk; @@ -509,7 +576,7 @@ g_mem_chunk_alloc (GMemChunk *mem_chunk) /* Determine which area this piece of memory is allocated from */ temp_area = g_tree_search (rmem_chunk->mem_tree, - (GSearchFunc) g_mem_chunk_area_search, + (GCompareFunc) g_mem_chunk_area_search, mem); /* If the area has been marked, then it is being destroyed. @@ -581,9 +648,15 @@ g_mem_chunk_alloc (GMemChunk *mem_chunk) } else { +#ifdef ENABLE_GC_FRIENDLY + rmem_chunk->mem_area = (GMemArea*) g_malloc0 (sizeof (GMemArea) - + MEM_AREA_SIZE + + rmem_chunk->area_size); +#else /* !ENABLE_GC_FRIENDLY */ rmem_chunk->mem_area = (GMemArea*) g_malloc (sizeof (GMemArea) - MEM_AREA_SIZE + rmem_chunk->area_size); +#endif /* ENABLE_GC_FRIENDLY */ rmem_chunk->num_mem_areas += 1; rmem_chunk->mem_area->next = rmem_chunk->mem_areas; @@ -641,13 +714,17 @@ g_mem_chunk_free (GMemChunk *mem_chunk, GMemArea *temp_area; GFreeAtom *free_atom; - g_assert (mem_chunk != NULL); - g_assert (mem != NULL); + g_return_if_fail (mem_chunk != NULL); + g_return_if_fail (mem != NULL); ENTER_MEM_CHUNK_ROUTINE(); rmem_chunk = (GRealMemChunk*) mem_chunk; +#ifdef ENABLE_GC_FRIENDLY + memset (mem, 0, rmem_chunk->atom_size); +#endif /* ENABLE_GC_FRIENDLY */ + /* Don't do anything if this is an ALLOC_ONLY chunk */ if (rmem_chunk->type == G_ALLOC_AND_FREE) @@ -659,7 +736,7 @@ g_mem_chunk_free (GMemChunk *mem_chunk, rmem_chunk->free_atoms = free_atom; temp_area = g_tree_search (rmem_chunk->mem_tree, - (GSearchFunc) g_mem_chunk_area_search, + (GCompareFunc) g_mem_chunk_area_search, mem); temp_area->allocated -= 1; @@ -684,7 +761,7 @@ g_mem_chunk_clean (GMemChunk *mem_chunk) GFreeAtom *temp_free_atom; gpointer mem; - g_assert (mem_chunk != NULL); + g_return_if_fail (mem_chunk != NULL); rmem_chunk = (GRealMemChunk*) mem_chunk; @@ -698,7 +775,7 @@ g_mem_chunk_clean (GMemChunk *mem_chunk) mem = (gpointer) temp_free_atom; mem_area = g_tree_search (rmem_chunk->mem_tree, - (GSearchFunc) g_mem_chunk_area_search, + (GCompareFunc) g_mem_chunk_area_search, mem); /* If this mem area is marked for destruction then delete the @@ -748,7 +825,7 @@ g_mem_chunk_reset (GMemChunk *mem_chunk) GMemArea *mem_areas; GMemArea *temp_area; - g_assert (mem_chunk != NULL); + g_return_if_fail (mem_chunk != NULL); rmem_chunk = (GRealMemChunk*) mem_chunk; @@ -778,7 +855,7 @@ g_mem_chunk_print (GMemChunk *mem_chunk) GMemArea *mem_areas; gulong mem; - g_assert (mem_chunk != NULL); + g_return_if_fail (mem_chunk != NULL); rmem_chunk = (GRealMemChunk*) mem_chunk; mem_areas = rmem_chunk->mem_areas; @@ -791,7 +868,7 @@ g_mem_chunk_print (GMemChunk *mem_chunk) } g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, - "%s: %ld bytes using %d mem areas\n", + "%s: %ld bytes using %d mem areas", rmem_chunk->name, mem, rmem_chunk->num_mem_areas); } @@ -802,21 +879,26 @@ g_mem_chunk_info (void) gint count; count = 0; + g_mutex_lock (mem_chunks_lock); mem_chunk = mem_chunks; while (mem_chunk) { count += 1; mem_chunk = mem_chunk->next; } + g_mutex_unlock (mem_chunks_lock); - g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%d mem chunks\n", count); + g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%d mem chunks", count); + g_mutex_lock (mem_chunks_lock); mem_chunk = mem_chunks; + g_mutex_unlock (mem_chunks_lock); + while (mem_chunk) { g_mem_chunk_print ((GMemChunk*) mem_chunk); mem_chunk = mem_chunk->next; - } + } } void @@ -824,7 +906,9 @@ g_blow_chunks (void) { GRealMemChunk *mem_chunk; + g_mutex_lock (mem_chunks_lock); mem_chunk = mem_chunks; + g_mutex_unlock (mem_chunks_lock); while (mem_chunk) { g_mem_chunk_clean ((GMemChunk*) mem_chunk); @@ -834,7 +918,8 @@ g_blow_chunks (void) static gulong -g_mem_chunk_compute_size (gulong size) +g_mem_chunk_compute_size (gulong size, + gulong min_size) { gulong power_of_2; gulong lower, upper; @@ -846,16 +931,21 @@ g_mem_chunk_compute_size (gulong size) lower = power_of_2 >> 1; upper = power_of_2; - if ((size - lower) < (upper - size)) + if (size - lower < upper - size && lower >= min_size) return lower; - return upper; + else + return upper; } static gint g_mem_chunk_area_compare (GMemArea *a, GMemArea *b) { - return (a->mem - b->mem); + if (a->mem > b->mem) + return 1; + else if (a->mem < b->mem) + return -1; + return 0; } static gint @@ -870,3 +960,59 @@ g_mem_chunk_area_search (GMemArea *a, } return -1; } + +/* generic allocators + */ +struct _GAllocator /* from gmem.c */ +{ + gchar *name; + guint16 n_preallocs; + guint is_unused : 1; + guint type : 4; + GAllocator *last; + GMemChunk *mem_chunk; + gpointer dummy; /* implementation specific */ +}; + +GAllocator* +g_allocator_new (const gchar *name, + guint n_preallocs) +{ + GAllocator *allocator; + + g_return_val_if_fail (name != NULL, NULL); + + allocator = g_new0 (GAllocator, 1); + allocator->name = g_strdup (name); + allocator->n_preallocs = CLAMP (n_preallocs, 1, 65535); + allocator->is_unused = TRUE; + allocator->type = 0; + allocator->last = NULL; + allocator->mem_chunk = NULL; + allocator->dummy = NULL; + + return allocator; +} + +void +g_allocator_free (GAllocator *allocator) +{ + g_return_if_fail (allocator != NULL); + g_return_if_fail (allocator->is_unused == TRUE); + + g_free (allocator->name); + if (allocator->mem_chunk) + g_mem_chunk_destroy (allocator->mem_chunk); + + g_free (allocator); +} + +void +g_mem_init (void) +{ + mem_chunks_lock = g_mutex_new(); +#ifdef ENABLE_MEM_PROFILE + mem_profile_lock = g_mutex_new(); + allocating_for_mem_chunk = g_private_new(NULL); +#endif +}