X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=glib%2Fgmem.c;h=de08b335c74b49ec8549e3b8104349c73f41319f;hb=4454b815367831a71b1ae00b0182b5b389a78df2;hp=a657f73fd02a0d9136e02a9dbceaef2f4d501cee;hpb=fdaaa22b58b20c285bc0c328cd6a97bb6c0f0258;p=platform%2Fupstream%2Fglib.git diff --git a/glib/gmem.c b/glib/gmem.c index a657f73..de08b33 100644 --- a/glib/gmem.c +++ b/glib/gmem.c @@ -12,9 +12,7 @@ * 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., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library; if not, see . */ /* @@ -36,89 +34,29 @@ #include #include +#include "gslice.h" #include "gbacktrace.h" #include "gtestutils.h" #include "gthread.h" #include "glib_trace.h" - #define MEM_PROFILE_TABLE_SIZE 4096 /* notes on macros: * having G_DISABLE_CHECKS defined disables use of glib_mem_profiler_table and * g_mem_profile(). - * REALLOC_0_WORKS is defined if g_realloc (NULL, x) works. - * SANE_MALLOC_PROTOS is defined if the systems malloc() and friends functions - * match the corresponding GLib prototypes, keep configure.ac and gmem.h in sync here. - * g_mem_gc_friendly is TRUE, freed memory should be 0-wiped. + * If g_mem_gc_friendly is TRUE, freed memory should be 0-wiped. */ -/* --- prototypes --- */ -static gboolean g_mem_initialized = FALSE; -static void g_mem_init_nomessage (void); - - -/* --- malloc wrappers --- */ -#ifndef REALLOC_0_WORKS -static gpointer -standard_realloc (gpointer mem, - gsize n_bytes) -{ - if (!mem) - return malloc (n_bytes); - else - return realloc (mem, n_bytes); -} -#endif /* !REALLOC_0_WORKS */ - -#ifdef SANE_MALLOC_PROTOS -# define standard_malloc malloc -# ifdef REALLOC_0_WORKS -# define standard_realloc realloc -# endif /* REALLOC_0_WORKS */ -# define standard_free free -# define standard_calloc calloc -# define standard_try_malloc malloc -# define standard_try_realloc realloc -#else /* !SANE_MALLOC_PROTOS */ -static gpointer -standard_malloc (gsize n_bytes) -{ - return malloc (n_bytes); -} -# ifdef REALLOC_0_WORKS -static gpointer -standard_realloc (gpointer mem, - gsize n_bytes) -{ - return realloc (mem, n_bytes); -} -# endif /* REALLOC_0_WORKS */ -static void -standard_free (gpointer mem) -{ - free (mem); -} -static gpointer -standard_calloc (gsize n_blocks, - gsize n_bytes) -{ - return calloc (n_blocks, n_bytes); -} -#define standard_try_malloc standard_malloc -#define standard_try_realloc standard_realloc -#endif /* !SANE_MALLOC_PROTOS */ - - /* --- variables --- */ static GMemVTable glib_mem_vtable = { - standard_malloc, - standard_realloc, - standard_free, - standard_calloc, - standard_try_malloc, - standard_try_realloc, + malloc, + realloc, + free, + calloc, + malloc, + realloc, }; /** @@ -128,18 +66,15 @@ static GMemVTable glib_mem_vtable = { * * These functions provide support for allocating and freeing memory. * - * * If any call to allocate memory fails, the application is terminated. * This also means that there is no need to check if the call succeeded. - * * - * - * It's important to match g_malloc() with g_free(), plain malloc() with free(), - * and (if you're using C++) new with delete and new[] with delete[]. Otherwise - * bad things can happen, since these allocators may use different memory - * pools (and new/delete call constructors and destructors). See also - * g_mem_set_vtable(). - * + * It's important to match g_malloc() (and wrappers such as g_new()) with + * g_free(), g_slice_alloc() and wrappers such as g_slice_new()) with + * g_slice_free(), plain malloc() with free(), and (if you're using C++) + * new with delete and new[] with delete[]. Otherwise bad things can happen, + * since these allocators may use different memory pools (and new/delete call + * constructors and destructors). See also g_mem_set_vtable(). */ /* --- functions --- */ @@ -155,8 +90,6 @@ static GMemVTable glib_mem_vtable = { gpointer g_malloc (gsize n_bytes) { - if (G_UNLIKELY (!g_mem_initialized)) - g_mem_init_nomessage(); if (G_LIKELY (n_bytes)) { gpointer mem; @@ -187,8 +120,6 @@ g_malloc (gsize n_bytes) gpointer g_malloc0 (gsize n_bytes) { - if (G_UNLIKELY (!g_mem_initialized)) - g_mem_init_nomessage(); if (G_LIKELY (n_bytes)) { gpointer mem; @@ -209,7 +140,7 @@ g_malloc0 (gsize n_bytes) /** * g_realloc: - * @mem: the memory to reallocate + * @mem: (allow-none): the memory to reallocate * @n_bytes: new size of the memory in bytes * * Reallocates the memory pointed to by @mem, so that it now has space for @@ -226,8 +157,6 @@ g_realloc (gpointer mem, { gpointer newmem; - if (G_UNLIKELY (!g_mem_initialized)) - g_mem_init_nomessage(); if (G_LIKELY (n_bytes)) { newmem = glib_mem_vtable.realloc (mem, n_bytes); @@ -249,7 +178,7 @@ g_realloc (gpointer mem, /** * g_free: - * @mem: the memory to free + * @mem: (allow-none): the memory to free * * Frees the memory pointed to by @mem. * If @mem is %NULL it simply returns. @@ -257,14 +186,45 @@ g_realloc (gpointer mem, void g_free (gpointer mem) { - if (G_UNLIKELY (!g_mem_initialized)) - g_mem_init_nomessage(); if (G_LIKELY (mem)) glib_mem_vtable.free (mem); TRACE(GLIB_MEM_FREE((void*) mem)); } /** + * g_clear_pointer: (skip) + * @pp: a pointer to a variable, struct member etc. holding a pointer + * @destroy: a function to which a gpointer can be passed, to destroy *@pp + * + * Clears a reference to a variable. + * + * @pp must not be %NULL. + * + * If the reference is %NULL then this function does nothing. + * Otherwise, the variable is destroyed using @destroy and the + * pointer is set to %NULL. + * + * A macro is also included that allows this function to be used without + * pointer casts. + * + * Since: 2.34 + **/ +#undef g_clear_pointer +void +g_clear_pointer (gpointer *pp, + GDestroyNotify destroy) +{ + gpointer _p; + + _p = *pp; + if (_p) + { + *pp = NULL; + destroy (_p); + } +} + +/** * g_try_malloc: * @n_bytes: number of bytes to allocate. * @@ -278,8 +238,6 @@ g_try_malloc (gsize n_bytes) { gpointer mem; - if (G_UNLIKELY (!g_mem_initialized)) - g_mem_init_nomessage(); if (G_LIKELY (n_bytes)) mem = glib_mem_vtable.try_malloc (n_bytes); else @@ -305,8 +263,6 @@ g_try_malloc0 (gsize n_bytes) { gpointer mem; - if (G_UNLIKELY (!g_mem_initialized)) - g_mem_init_nomessage(); if (G_LIKELY (n_bytes)) mem = glib_mem_vtable.try_malloc (n_bytes); else @@ -320,7 +276,7 @@ g_try_malloc0 (gsize n_bytes) /** * g_try_realloc: - * @mem: previously-allocated memory, or %NULL. + * @mem: (allow-none): previously-allocated memory, or %NULL. * @n_bytes: number of bytes to allocate. * * Attempts to realloc @mem to a new size, @n_bytes, and returns %NULL @@ -335,8 +291,6 @@ g_try_realloc (gpointer mem, { gpointer newmem; - if (G_UNLIKELY (!g_mem_initialized)) - g_mem_init_nomessage(); if (G_LIKELY (n_bytes)) newmem = glib_mem_vtable.try_realloc (mem, n_bytes); else @@ -371,9 +325,6 @@ g_malloc_n (gsize n_blocks, { if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) { - if (G_UNLIKELY (!g_mem_initialized)) - g_mem_init_nomessage(); - g_error ("%s: overflow allocating %"G_GSIZE_FORMAT"*%"G_GSIZE_FORMAT" bytes", G_STRLOC, n_blocks, n_block_bytes); } @@ -398,9 +349,6 @@ g_malloc0_n (gsize n_blocks, { if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) { - if (G_UNLIKELY (!g_mem_initialized)) - g_mem_init_nomessage(); - g_error ("%s: overflow allocating %"G_GSIZE_FORMAT"*%"G_GSIZE_FORMAT" bytes", G_STRLOC, n_blocks, n_block_bytes); } @@ -410,7 +358,7 @@ g_malloc0_n (gsize n_blocks, /** * g_realloc_n: - * @mem: the memory to reallocate + * @mem: (allow-none): the memory to reallocate * @n_blocks: the number of blocks to allocate * @n_block_bytes: the size of each block in bytes * @@ -427,9 +375,6 @@ g_realloc_n (gpointer mem, { if (SIZE_OVERFLOWS (n_blocks, n_block_bytes)) { - if (G_UNLIKELY (!g_mem_initialized)) - g_mem_init_nomessage(); - g_error ("%s: overflow allocating %"G_GSIZE_FORMAT"*%"G_GSIZE_FORMAT" bytes", G_STRLOC, n_blocks, n_block_bytes); } @@ -481,7 +426,7 @@ g_try_malloc0_n (gsize n_blocks, /** * g_try_realloc_n: - * @mem: previously-allocated memory, or %NULL. + * @mem: (allow-none): previously-allocated memory, or %NULL. * @n_blocks: the number of blocks to allocate * @n_block_bytes: the size of each block in bytes * @@ -520,7 +465,7 @@ fallback_calloc (gsize n_blocks, static gboolean vtable_set = FALSE; /** - * g_mem_is_system_malloc + * g_mem_is_system_malloc: * * Checks whether the allocator used by g_malloc() is the system's * malloc implementation. If it returns %TRUE memory allocated with @@ -530,7 +475,7 @@ static gboolean vtable_set = FALSE; * * A different allocator can be set using g_mem_set_vtable(). * - * Return value: if %TRUE, malloc() and g_malloc() can be mixed. + * Returns: if %TRUE, malloc() and g_malloc() can be mixed. **/ gboolean g_mem_is_system_malloc (void) @@ -542,13 +487,17 @@ g_mem_is_system_malloc (void) * g_mem_set_vtable: * @vtable: table of memory allocation routines. * - * Sets the #GMemVTable to use for memory allocation. You can use this to provide - * custom memory allocation routines. This function must be called - * before using any other GLib functions. The @vtable only needs to - * provide malloc(), realloc(), and free() functions; GLib can provide default - * implementations of the others. The malloc() and realloc() implementations - * should return %NULL on failure, GLib will handle error-checking for you. - * @vtable is copied, so need not persist after this function has been called. + * Sets the #GMemVTable to use for memory allocation. You can use this + * to provide custom memory allocation routines. + * + * The @vtable only needs to provide malloc(), realloc(), and free() + * functions; GLib can provide default implementations of the others. + * The malloc() and realloc() implementations should return %NULL on + * failure, GLib will handle error-checking for you. @vtable is copied, + * so need not persist after this function has been called. + * + * Note that this function must be called before using any other GLib + * functions. */ void g_mem_set_vtable (GMemVTable *vtable) @@ -599,12 +548,7 @@ static guint *profile_data = NULL; static gsize profile_allocs = 0; static gsize profile_zinit = 0; static gsize profile_frees = 0; -static GMutex *gmem_profile_mutex = NULL; -#ifdef G_ENABLE_DEBUG -static volatile gsize g_trap_free_size = 0; -static volatile gsize g_trap_realloc_size = 0; -static volatile gsize g_trap_malloc_size = 0; -#endif /* G_ENABLE_DEBUG */ +static GMutex gmem_profile_mutex; #define PROFILE_TABLE(f1,f2,f3) ( ( ((f3) << 2) | ((f2) << 1) | (f1) ) * (MEM_PROFILE_TABLE_SIZE + 1)) @@ -613,14 +557,14 @@ profiler_log (ProfilerJob job, gsize n_bytes, gboolean success) { - g_mutex_lock (gmem_profile_mutex); + g_mutex_lock (&gmem_profile_mutex); if (!profile_data) { - profile_data = standard_calloc ((MEM_PROFILE_TABLE_SIZE + 1) * 8, - sizeof (profile_data[0])); + profile_data = calloc ((MEM_PROFILE_TABLE_SIZE + 1) * 8, + sizeof (profile_data[0])); if (!profile_data) /* memory system kiddin' me, eh? */ { - g_mutex_unlock (gmem_profile_mutex); + g_mutex_unlock (&gmem_profile_mutex); return; } } @@ -644,7 +588,7 @@ profiler_log (ProfilerJob job, else profile_frees += n_bytes; } - g_mutex_unlock (gmem_profile_mutex); + g_mutex_unlock (&gmem_profile_mutex); } static void @@ -685,7 +629,6 @@ profile_print_locked (guint *local_data, /** * g_mem_profile: - * @void: * * Outputs a summary of memory usage. * @@ -702,15 +645,12 @@ profile_print_locked (guint *local_data, void g_mem_profile (void) { - guint local_data[(MEM_PROFILE_TABLE_SIZE + 1) * 8 * sizeof (profile_data[0])]; + guint local_data[(MEM_PROFILE_TABLE_SIZE + 1) * 8]; gsize local_allocs; gsize local_zinit; gsize local_frees; - if (G_UNLIKELY (!g_mem_initialized)) - g_mem_init_nomessage(); - - g_mutex_lock (gmem_profile_mutex); + g_mutex_lock (&gmem_profile_mutex); local_allocs = profile_allocs; local_zinit = profile_zinit; @@ -718,14 +658,14 @@ g_mem_profile (void) if (!profile_data) { - g_mutex_unlock (gmem_profile_mutex); + g_mutex_unlock (&gmem_profile_mutex); return; } memcpy (local_data, profile_data, (MEM_PROFILE_TABLE_SIZE + 1) * 8 * sizeof (profile_data[0])); - g_mutex_unlock (gmem_profile_mutex); + g_mutex_unlock (&gmem_profile_mutex); g_print ("GLib Memory statistics (successful operations):\n"); profile_print_locked (local_data, TRUE); @@ -748,12 +688,7 @@ profiler_try_malloc (gsize n_bytes) { gsize *p; -#ifdef G_ENABLE_DEBUG - if (g_trap_malloc_size == n_bytes) - G_BREAKPOINT (); -#endif /* G_ENABLE_DEBUG */ - - p = standard_malloc (sizeof (gsize) * 2 + n_bytes); + p = malloc (sizeof (gsize) * 2 + n_bytes); if (p) { @@ -786,12 +721,7 @@ profiler_calloc (gsize n_blocks, gsize l = n_blocks * n_block_bytes; gsize *p; -#ifdef G_ENABLE_DEBUG - if (g_trap_malloc_size == l) - G_BREAKPOINT (); -#endif /* G_ENABLE_DEBUG */ - - p = standard_calloc (1, sizeof (gsize) * 2 + l); + p = calloc (1, sizeof (gsize) * 2 + l); if (p) { @@ -825,17 +755,12 @@ profiler_free (gpointer mem) } else { -#ifdef G_ENABLE_DEBUG - if (g_trap_free_size == p[1]) - G_BREAKPOINT (); -#endif /* G_ENABLE_DEBUG */ - profiler_log (PROFILER_FREE, p[1], /* length */ TRUE); memset (p + 2, 0xaa, p[1]); - /* for all those that miss standard_free (p); in this place, yes, + /* for all those that miss free (p); in this place, yes, * we do leak all memory when profiling, and that is intentional * to catch double frees. patch submissions are futile. */ @@ -850,11 +775,6 @@ profiler_try_realloc (gpointer mem, gsize *p = mem; p -= 2; - -#ifdef G_ENABLE_DEBUG - if (g_trap_realloc_size == n_bytes) - G_BREAKPOINT (); -#endif /* G_ENABLE_DEBUG */ if (mem && p[0]) /* free count */ { @@ -867,7 +787,7 @@ profiler_try_realloc (gpointer mem, } else { - p = standard_realloc (mem ? p : NULL, sizeof (gsize) * 2 + n_bytes); + p = realloc (mem ? p : NULL, sizeof (gsize) * 2 + n_bytes); if (p) { @@ -908,490 +828,3 @@ static GMemVTable profiler_table = { GMemVTable *glib_mem_profiler_table = &profiler_table; #endif /* !G_DISABLE_CHECKS */ - -/* --- MemChunks --- */ -/** - * SECTION:allocators - * @title: Memory Allocators - * @short_description: deprecated way to allocate chunks of memory for - * GList, GSList and GNode - * - * Prior to 2.10, #GAllocator was used as an efficient way to allocate - * small pieces of memory for use with the #GList, #GSList and #GNode - * data structures. Since 2.10, it has been completely replaced by the - * slice allocator and - * deprecated. - **/ - -/** - * SECTION:memory_chunks - * @title: Memory Chunks - * @short_description: deprecated way to allocate groups of equal-sized - * chunks of memory - * - * Memory chunks provide an space-efficient way to allocate equal-sized - * pieces of memory, called atoms. However, due to the administrative - * overhead (in particular for #G_ALLOC_AND_FREE, and when used from - * multiple threads), they are in practise often slower than direct use - * of g_malloc(). Therefore, memory chunks have been deprecated in - * favor of the slice - * allocator, which has been added in 2.10. All internal uses of - * memory chunks in GLib have been converted to the - * g_slice API. - * - * There are two types of memory chunks, #G_ALLOC_ONLY, and - * #G_ALLOC_AND_FREE. #G_ALLOC_ONLY - * chunks only allow allocation of atoms. The atoms can never be freed - * individually. The memory chunk can only be free in its entirety. - * #G_ALLOC_AND_FREE chunks do - * allow atoms to be freed individually. The disadvantage of this is - * that the memory chunk has to keep track of which atoms have been - * freed. This results in more memory being used and a slight - * degradation in performance. - * - * To create a memory chunk use g_mem_chunk_new() or the convenience - * macro g_mem_chunk_create(). - * - * To allocate a new atom use g_mem_chunk_alloc(), - * g_mem_chunk_alloc0(), or the convenience macros g_chunk_new() or - * g_chunk_new0(). - * - * To free an atom use g_mem_chunk_free(), or the convenience macro - * g_chunk_free(). (Atoms can only be freed if the memory chunk is - * created with the type set to #G_ALLOC_AND_FREE.) - * - * To free any blocks of memory which are no longer being used, use - * g_mem_chunk_clean(). To clean all memory chunks, use g_blow_chunks(). - * - * To reset the memory chunk, freeing all of the atoms, use - * g_mem_chunk_reset(). - * - * To destroy a memory chunk, use g_mem_chunk_destroy(). - * - * To help debug memory chunks, use g_mem_chunk_info() and - * g_mem_chunk_print(). - * - * - * Using a #GMemChunk - * - * GMemChunk *mem_chunk; - * gchar *mem[10000]; - * gint i; - * - * /* Create a GMemChunk with atoms 50 bytes long, and memory - * blocks holding 100 bytes. Note that this means that only 2 atoms - * fit into each memory block and so isn't very efficient. */ - * mem_chunk = g_mem_chunk_new ("test mem chunk", 50, 100, G_ALLOC_AND_FREE); - * /* Now allocate 10000 atoms. */ - * for (i = 0; i < 10000; i++) - * { - * mem[i] = g_chunk_new (gchar, mem_chunk); - * /* Fill in the atom memory with some junk. */ - * for (j = 0; j < 50; j++) - * mem[i][j] = i * j; - * } - * /* Now free all of the atoms. Note that since we are going to - * destroy the GMemChunk, this wouldn't normally be used. */ - * for (i = 0; i < 10000; i++) - * { - * g_mem_chunk_free (mem_chunk, mem[i]); - * } - * /* We are finished with the GMemChunk, so we destroy it. */ - * g_mem_chunk_destroy (mem_chunk); - * - * - * - * - * Using a #GMemChunk with data structures - * - * GMemChunk *array_mem_chunk; - * GRealArray *array; - * /* Create a GMemChunk to hold GRealArray structures, using - * the g_mem_chunk_create() convenience macro. We want 1024 atoms in each - * memory block, and we want to be able to free individual atoms. */ - * array_mem_chunk = g_mem_chunk_create (GRealArray, 1024, G_ALLOC_AND_FREE); - * /* Allocate one atom, using the g_chunk_new() convenience macro. */ - * array = g_chunk_new (GRealArray, array_mem_chunk); - * /* We can now use array just like a normal pointer to a structure. */ - * array->data = NULL; - * array->len = 0; - * array->alloc = 0; - * array->zero_terminated = (zero_terminated ? 1 : 0); - * array->clear = (clear ? 1 : 0); - * array->elt_size = elt_size; - * /* We can free the element, so it can be reused. */ - * g_chunk_free (array, array_mem_chunk); - * /* We destroy the GMemChunk when we are finished with it. */ - * g_mem_chunk_destroy (array_mem_chunk); - * - * - **/ - -#ifndef G_ALLOC_AND_FREE - -/** - * GAllocator: - * - * The #GAllocator struct contains private data. and should only be - * accessed using the following functions. - **/ -typedef struct _GAllocator GAllocator; - -/** - * GMemChunk: - * - * The #GMemChunk struct is an opaque data structure representing a - * memory chunk. It should be accessed only through the use of the - * following functions. - **/ -typedef struct _GMemChunk GMemChunk; - -/** - * G_ALLOC_ONLY: - * - * Specifies the type of a #GMemChunk. Used in g_mem_chunk_new() and - * g_mem_chunk_create() to specify that atoms will never be freed - * individually. - **/ -#define G_ALLOC_ONLY 1 - -/** - * G_ALLOC_AND_FREE: - * - * Specifies the type of a #GMemChunk. Used in g_mem_chunk_new() and - * g_mem_chunk_create() to specify that atoms will be freed - * individually. - **/ -#define G_ALLOC_AND_FREE 2 -#endif - -struct _GMemChunk { - guint alloc_size; /* the size of an atom */ -}; - -/** - * g_mem_chunk_new: - * @name: a string to identify the #GMemChunk. It is not copied so it - * should be valid for the lifetime of the #GMemChunk. It is - * only used in g_mem_chunk_print(), which is used for debugging. - * @atom_size: the size, in bytes, of each element in the #GMemChunk. - * @area_size: the size, in bytes, of each block of memory allocated to - * contain the atoms. - * @type: the type of the #GMemChunk. #G_ALLOC_AND_FREE is used if the - * atoms will be freed individually. #G_ALLOC_ONLY should be - * used if atoms will never be freed individually. - * #G_ALLOC_ONLY is quicker, since it does not need to track - * free atoms, but it obviously wastes memory if you no longer - * need many of the atoms. - * @Returns: the new #GMemChunk. - * - * Creates a new #GMemChunk. - * - * Deprecated:2.10: Use the slice - * allocator instead - **/ -GMemChunk* -g_mem_chunk_new (const gchar *name, - gint atom_size, - gsize area_size, - gint type) -{ - GMemChunk *mem_chunk; - g_return_val_if_fail (atom_size > 0, NULL); - - mem_chunk = g_slice_new (GMemChunk); - mem_chunk->alloc_size = atom_size; - return mem_chunk; -} - -/** - * g_mem_chunk_destroy: - * @mem_chunk: a #GMemChunk. - * - * Frees all of the memory allocated for a #GMemChunk. - * - * Deprecated:2.10: Use the slice - * allocator instead - **/ -void -g_mem_chunk_destroy (GMemChunk *mem_chunk) -{ - g_return_if_fail (mem_chunk != NULL); - - g_slice_free (GMemChunk, mem_chunk); -} - -/** - * g_mem_chunk_alloc: - * @mem_chunk: a #GMemChunk. - * @Returns: a pointer to the allocated atom. - * - * Allocates an atom of memory from a #GMemChunk. - * - * Deprecated:2.10: Use g_slice_alloc() instead - **/ -gpointer -g_mem_chunk_alloc (GMemChunk *mem_chunk) -{ - g_return_val_if_fail (mem_chunk != NULL, NULL); - - return g_slice_alloc (mem_chunk->alloc_size); -} - -/** - * g_mem_chunk_alloc0: - * @mem_chunk: a #GMemChunk. - * @Returns: a pointer to the allocated atom. - * - * Allocates an atom of memory from a #GMemChunk, setting the memory to - * 0. - * - * Deprecated:2.10: Use g_slice_alloc0() instead - **/ -gpointer -g_mem_chunk_alloc0 (GMemChunk *mem_chunk) -{ - g_return_val_if_fail (mem_chunk != NULL, NULL); - - return g_slice_alloc0 (mem_chunk->alloc_size); -} - -/** - * g_mem_chunk_free: - * @mem_chunk: a #GMemChunk. - * @mem: a pointer to the atom to free. - * - * Frees an atom in a #GMemChunk. This should only be called if the - * #GMemChunk was created with #G_ALLOC_AND_FREE. Otherwise it will - * simply return. - * - * Deprecated:2.10: Use g_slice_free1() instead - **/ -void -g_mem_chunk_free (GMemChunk *mem_chunk, - gpointer mem) -{ - g_return_if_fail (mem_chunk != NULL); - - g_slice_free1 (mem_chunk->alloc_size, mem); -} - -/** - * g_mem_chunk_clean: - * @mem_chunk: a #GMemChunk. - * - * Frees any blocks in a #GMemChunk which are no longer being used. - * - * Deprecated:2.10: Use the slice - * allocator instead - **/ -void g_mem_chunk_clean (GMemChunk *mem_chunk) {} - -/** - * g_mem_chunk_reset: - * @mem_chunk: a #GMemChunk. - * - * Resets a GMemChunk to its initial state. It frees all of the - * currently allocated blocks of memory. - * - * Deprecated:2.10: Use the slice - * allocator instead - **/ -void g_mem_chunk_reset (GMemChunk *mem_chunk) {} - - -/** - * g_mem_chunk_print: - * @mem_chunk: a #GMemChunk. - * - * Outputs debugging information for a #GMemChunk. It outputs the name - * of the #GMemChunk (set with g_mem_chunk_new()), the number of bytes - * used, and the number of blocks of memory allocated. - * - * Deprecated:2.10: Use the slice - * allocator instead - **/ -void g_mem_chunk_print (GMemChunk *mem_chunk) {} - - -/** - * g_mem_chunk_info: - * - * Outputs debugging information for all #GMemChunk objects currently - * in use. It outputs the number of #GMemChunk objects currently - * allocated, and calls g_mem_chunk_print() to output information on - * each one. - * - * Deprecated:2.10: Use the slice - * allocator instead - **/ -void g_mem_chunk_info (void) {} - -/** - * g_blow_chunks: - * - * Calls g_mem_chunk_clean() on all #GMemChunk objects. - * - * Deprecated:2.10: Use the slice - * allocator instead - **/ -void g_blow_chunks (void) {} - -/** - * g_chunk_new0: - * @type: the type of the #GMemChunk atoms, typically a structure name. - * @chunk: a #GMemChunk. - * @Returns: a pointer to the allocated atom, cast to a pointer to - * @type. - * - * A convenience macro to allocate an atom of memory from a #GMemChunk. - * It calls g_mem_chunk_alloc0() and casts the returned atom to a - * pointer to the given type, avoiding a type cast in the source code. - * - * Deprecated:2.10: Use g_slice_new0() instead - **/ - -/** - * g_chunk_free: - * @mem: a pointer to the atom to be freed. - * @mem_chunk: a #GMemChunk. - * - * A convenience macro to free an atom of memory from a #GMemChunk. It - * simply switches the arguments and calls g_mem_chunk_free() It is - * included simply to complement the other convenience macros, - * g_chunk_new() and g_chunk_new0(). - * - * Deprecated:2.10: Use g_slice_free() instead - **/ - -/** - * g_chunk_new: - * @type: the type of the #GMemChunk atoms, typically a structure name. - * @chunk: a #GMemChunk. - * @Returns: a pointer to the allocated atom, cast to a pointer to - * @type. - * - * A convenience macro to allocate an atom of memory from a #GMemChunk. - * It calls g_mem_chunk_alloc() and casts the returned atom to a - * pointer to the given type, avoiding a type cast in the source code. - * - * Deprecated:2.10: Use g_slice_new() instead - **/ - -/** - * g_mem_chunk_create: - * @type: the type of the atoms, typically a structure name. - * @pre_alloc: the number of atoms to store in each block of memory. - * @alloc_type: the type of the #GMemChunk. #G_ALLOC_AND_FREE is used - * if the atoms will be freed individually. #G_ALLOC_ONLY - * should be used if atoms will never be freed - * individually. #G_ALLOC_ONLY is quicker, since it does - * not need to track free atoms, but it obviously wastes - * memory if you no longer need many of the atoms. - * @Returns: the new #GMemChunk. - * - * A convenience macro for creating a new #GMemChunk. It calls - * g_mem_chunk_new(), using the given type to create the #GMemChunk - * name. The atom size is determined using - * sizeof(), and the area size is calculated by - * multiplying the @pre_alloc parameter with the atom size. - * - * Deprecated:2.10: Use the slice - * allocator instead - **/ - - -/** - * g_allocator_new: - * @name: the name of the #GAllocator. This name is used to set the - * name of the #GMemChunk used by the #GAllocator, and is only - * used for debugging. - * @n_preallocs: the number of elements in each block of memory - * allocated. Larger blocks mean less calls to - * g_malloc(), but some memory may be wasted. (GLib uses - * 128 elements per block by default.) The value must be - * between 1 and 65535. - * @Returns: a new #GAllocator. - * - * Creates a new #GAllocator. - * - * Deprecated:2.10: Use the slice - * allocator instead - **/ -GAllocator* -g_allocator_new (const gchar *name, - guint n_preallocs) -{ - static struct _GAllocator { - gchar *name; - guint16 n_preallocs; - guint is_unused : 1; - guint type : 4; - GAllocator *last; - GMemChunk *mem_chunk; - gpointer free_list; - } dummy = { - "GAllocator is deprecated", 1, TRUE, 0, NULL, NULL, NULL, - }; - /* some (broken) GAllocator uses depend on non-NULL allocators */ - return (void*) &dummy; -} - -/** - * g_allocator_free: - * @allocator: a #GAllocator. - * - * Frees all of the memory allocated by the #GAllocator. - * - * Deprecated:2.10: Use the slice - * allocator instead - **/ -void -g_allocator_free (GAllocator *allocator) -{ -} - -#ifdef ENABLE_GC_FRIENDLY_DEFAULT -gboolean g_mem_gc_friendly = TRUE; -#else -/** - * g_mem_gc_friendly: - * - * This variable is %TRUE if the G_DEBUG environment variable - * includes the key gc-friendly. - */ -gboolean g_mem_gc_friendly = FALSE; -#endif - -static void -g_mem_init_nomessage (void) -{ - gchar buffer[1024]; - const gchar *val; - const GDebugKey keys[] = { - { "gc-friendly", 1 }, - }; - gint flags; - if (g_mem_initialized) - return; - /* don't use g_malloc/g_message here */ - val = _g_getenv_nomalloc ("G_DEBUG", buffer); - flags = !val ? 0 : g_parse_debug_string (val, keys, G_N_ELEMENTS (keys)); - if (flags & 1) /* gc-friendly */ - { - g_mem_gc_friendly = TRUE; - } - g_mem_initialized = TRUE; -} - -void -_g_mem_thread_init_noprivate_nomessage (void) -{ - /* we may only create mutexes here, locking/ - * unlocking a mutex does not yet work. - */ - g_mem_init_nomessage(); -#ifndef G_DISABLE_CHECKS - gmem_profile_mutex = g_mutex_new (); -#endif -}