luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-12-25 23:16:14 +01:00
Code Issues Packages Projects Releases Wiki Activity

new slice allocator implementation.

Browse Source 
Thu Dec  1 17:32:46 2005  Tim Janik  <timj@imendio.com>

        * glib/gslice.[hc]: new slice allocator implementation.

        * tests/slice-test.c: added random slice allocation test.

        * glib/gthread.[hc]: removed newly added private thread mem API.

        * glib/gthreadinit.h:
        * glib/gmessages.c:
        * glib/gthread.c:
        * glib/gmem.c: divided glib threading initialisation into three phases,
        initialisation where private keys and messaging are not available (only
        needed by gmem.c), initialisation without messaging but private keys
        available (gslice.c, gmessage.c), and full fledged initialisers that
        server the rest of glib. initialisation functions got renamed to reflect
        the limitations of their corresponding phases.

        * glib/gmem.c: removed memchunk code, defer allocations to
        g_slice_* instead.

        * glib/gmem.[hc]: removed g_slice_* skeletons.

        * glib/glib.symbols: added g_slice_* symbols.

        * configure.in: check for availability of posix_memalign(3), memalign(3)
        and valloc(3).

        * glib/Makefile.am: added gslice.[hc].
This commit is contained in:
Tim Janik 2005-12-01 16:34:33 +00:00 committed by Tim Janik
parent d871f19c30
commit 733b1789c1
16 changed files with 1406 additions and 760 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
ChangeLog
View File

@ -1,3 +1,33 @@
Thu Dec 1 17:32:46 2005 Tim Janik <timj@imendio.com>
* glib/gslice.[hc]: new slice allocator implementation.
* tests/slice-test.c: added random slice allocation test.
* glib/gthread.[hc]: removed newly added private thread mem API.
* glib/gthreadinit.h:
* glib/gmessages.c:
* glib/gthread.c:
* glib/gmem.c: divided glib threading initialisation into three phases,
initialisation where private keys and messaging are not available (only
needed by gmem.c), initialisation without messaging but private keys
available (gslice.c, gmessage.c), and full fledged initialisers that
server the rest of glib. initialisation functions got renamed to reflect
the limitations of their corresponding phases.
* glib/gmem.c: removed memchunk code, defer allocations to
g_slice_* instead.
* glib/gmem.[hc]: removed g_slice_* skeletons.
* glib/glib.symbols: added g_slice_* symbols.
* configure.in: check for availability of posix_memalign(3), memalign(3)
and valloc(3).
* glib/Makefile.am: added gslice.[hc].
2005-12-01 Tor Lillqvist <tml@novell.com>
* glib/gstdio.c (g_stat): In the Win32 implementation, strip

30
ChangeLog.pre-2-10
View File

@ -1,3 +1,33 @@
Thu Dec 1 17:32:46 2005 Tim Janik <timj@imendio.com>
* glib/gslice.[hc]: new slice allocator implementation.
* tests/slice-test.c: added random slice allocation test.
* glib/gthread.[hc]: removed newly added private thread mem API.
* glib/gthreadinit.h:
* glib/gmessages.c:
* glib/gthread.c:
* glib/gmem.c: divided glib threading initialisation into three phases,
initialisation where private keys and messaging are not available (only
needed by gmem.c), initialisation without messaging but private keys
available (gslice.c, gmessage.c), and full fledged initialisers that
server the rest of glib. initialisation functions got renamed to reflect
the limitations of their corresponding phases.
* glib/gmem.c: removed memchunk code, defer allocations to
g_slice_* instead.
* glib/gmem.[hc]: removed g_slice_* skeletons.
* glib/glib.symbols: added g_slice_* symbols.
* configure.in: check for availability of posix_memalign(3), memalign(3)
and valloc(3).
* glib/Makefile.am: added gslice.[hc].
2005-12-01 Tor Lillqvist <tml@novell.com>
* glib/gstdio.c (g_stat): In the Win32 implementation, strip

30
ChangeLog.pre-2-12
View File

@ -1,3 +1,33 @@
Thu Dec 1 17:32:46 2005 Tim Janik <timj@imendio.com>
* glib/gslice.[hc]: new slice allocator implementation.
* tests/slice-test.c: added random slice allocation test.
* glib/gthread.[hc]: removed newly added private thread mem API.
* glib/gthreadinit.h:
* glib/gmessages.c:
* glib/gthread.c:
* glib/gmem.c: divided glib threading initialisation into three phases,
initialisation where private keys and messaging are not available (only
needed by gmem.c), initialisation without messaging but private keys
available (gslice.c, gmessage.c), and full fledged initialisers that
server the rest of glib. initialisation functions got renamed to reflect
the limitations of their corresponding phases.
* glib/gmem.c: removed memchunk code, defer allocations to
g_slice_* instead.
* glib/gmem.[hc]: removed g_slice_* skeletons.
* glib/glib.symbols: added g_slice_* symbols.
* configure.in: check for availability of posix_memalign(3), memalign(3)
and valloc(3).
* glib/Makefile.am: added gslice.[hc].
2005-12-01 Tor Lillqvist <tml@novell.com>
* glib/gstdio.c (g_stat): In the Win32 implementation, strip

3
configure.in
View File

@ -523,6 +523,9 @@ AC_HEADER_STDC
AC_FUNC_VPRINTF
AC_FUNC_MMAP
AC_FUNC_ALLOCA
AC_CHECK_FUNCS(posix_memalign)
AC_CHECK_FUNCS(memalign)
AC_CHECK_FUNCS(valloc)
AC_CHECK_FUNCS(atexit on_exit)

2
glib/Makefile.am
View File

@ -104,6 +104,7 @@ libglib_2_0_la_SOURCES = \
grand.c \
gscanner.c \
gshell.c \
gslice.c \
gslist.c \
gstdio.c \
gstrfuncs.c \
@ -179,6 +180,7 @@ glibsubinclude_HEADERS = \
grel.h \
gscanner.h \
gshell.h \
gslice.h \
gslist.h \
gspawn.h \
gstdio.h \

16
glib/glib.symbols
View File

@ -584,10 +584,6 @@ g_realloc
g_try_malloc G_GNUC_MALLOC
g_try_malloc0 G_GNUC_MALLOC
g_try_realloc
g_slice_alloc
g_slice_alloc0
g_slice_free1
g_slice_free_chain
#ifndef G_DISABLE_DEPRECATED
g_allocator_free
g_allocator_new
@ -605,6 +601,18 @@ g_blow_chunks
#endif
#endif
#if IN_HEADER(__G_SLICE_H__)
#if IN_FILE(__G_SLICE_C__)
g_slice_alloc G_GNUC_MALLOC
g_slice_alloc0 G_GNUC_MALLOC
g_slice_free1
g_slice_free_chain
g_slice_set_config
g_slice_get_config
g_slice_get_config_state
#endif
#endif
#if IN_HEADER(__G_MESSAGES_H__)
#if IN_FILE(__G_MESSAGES_C__)
g_printf_string_upper_bound

736
glib/gmem.c
View File

@ -39,8 +39,6 @@
#include "galias.h"
/* notes on macros:
* having DISABLE_MEM_POOLS defined, disables mem_chunks alltogether, their
* allocations are performed through ordinary g_malloc/g_free.
* 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.
@ -51,19 +49,6 @@
#define MEM_PROFILE_TABLE_SIZE 4096
#define MEM_AREA_SIZE 4L
#ifdef G_DISABLE_CHECKS
# define ENTER_MEM_CHUNK_ROUTINE()
# define LEAVE_MEM_CHUNK_ROUTINE()
# define IN_MEM_CHUNK_ROUTINE() FALSE
#else /* !G_DISABLE_CHECKS */
static GPrivate* mem_chunk_recursion = NULL;
# define MEM_CHUNK_ROUTINE_COUNT() GPOINTER_TO_UINT (g_private_get (mem_chunk_recursion))
# define ENTER_MEM_CHUNK_ROUTINE() g_private_set (mem_chunk_recursion, GUINT_TO_POINTER (MEM_CHUNK_ROUTINE_COUNT () + 1))
# define LEAVE_MEM_CHUNK_ROUTINE() g_private_set (mem_chunk_recursion, GUINT_TO_POINTER (MEM_CHUNK_ROUTINE_COUNT () - 1))
#endif /* !G_DISABLE_CHECKS */
#ifndef REALLOC_0_WORKS
static gpointer
standard_realloc (gpointer mem,
@ -295,11 +280,9 @@ typedef enum {
} ProfilerJob;
static guint *profile_data = NULL;
static gulong profile_allocs = 0;
static gulong profile_mc_allocs = 0;
static gulong profile_zinit = 0;
static gulong profile_frees = 0;
static gulong profile_mc_frees = 0;
static GMutex *g_profile_mutex = NULL;
static GMutex *gmem_profile_mutex = NULL;
#ifdef G_ENABLE_DEBUG
static volatile gulong g_trap_free_size = 0;
static volatile gulong g_trap_realloc_size = 0;
@ -313,47 +296,37 @@ profiler_log (ProfilerJob job,
gulong n_bytes,
gboolean success)
{
g_mutex_lock (g_profile_mutex);
g_mutex_lock (gmem_profile_mutex);
if (!profile_data)
{
profile_data = standard_malloc ((MEM_PROFILE_TABLE_SIZE + 1) * 8 * sizeof (profile_data[0]));
if (!profile_data) /* memory system kiddin' me, eh? */
{
g_mutex_unlock (g_profile_mutex);
g_mutex_unlock (gmem_profile_mutex);
return;
}
}
if (MEM_CHUNK_ROUTINE_COUNT () == 0)
{
if (n_bytes < MEM_PROFILE_TABLE_SIZE)
profile_data[n_bytes + PROFILE_TABLE ((job & PROFILER_ALLOC) != 0,
(job & PROFILER_RELOC) != 0,
success != 0)] += 1;
else
profile_data[MEM_PROFILE_TABLE_SIZE + PROFILE_TABLE ((job & PROFILER_ALLOC) != 0,
(job & PROFILER_RELOC) != 0,
success != 0)] += 1;
if (success)
{
if (job & PROFILER_ALLOC)
{
profile_allocs += n_bytes;
if (job & PROFILER_ZINIT)
profile_zinit += n_bytes;
}
else
profile_frees += n_bytes;
}
}
else if (success)
if (n_bytes < MEM_PROFILE_TABLE_SIZE)
profile_data[n_bytes + PROFILE_TABLE ((job & PROFILER_ALLOC) != 0,
(job & PROFILER_RELOC) != 0,
success != 0)] += 1;
else
profile_data[MEM_PROFILE_TABLE_SIZE + PROFILE_TABLE ((job & PROFILER_ALLOC) != 0,
(job & PROFILER_RELOC) != 0,
success != 0)] += 1;
if (success)
{
if (job & PROFILER_ALLOC)
profile_mc_allocs += n_bytes;
{
profile_allocs += n_bytes;
if (job & PROFILER_ZINIT)
profile_zinit += n_bytes;
}
else
profile_mc_frees += n_bytes;
profile_frees += n_bytes;
}
g_mutex_unlock (g_profile_mutex);
g_mutex_unlock (gmem_profile_mutex);
}
static void
@ -399,27 +372,23 @@ g_mem_profile (void)
gulong local_allocs;
gulong local_zinit;
gulong local_frees;
gulong local_mc_allocs;
gulong local_mc_frees;
g_mutex_lock (g_profile_mutex);
g_mutex_lock (gmem_profile_mutex);
local_allocs = profile_allocs;
local_zinit = profile_zinit;
local_frees = profile_frees;
local_mc_allocs = profile_mc_allocs;
local_mc_frees = profile_mc_frees;
if (!profile_data)
{
g_mutex_unlock (g_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 (g_profile_mutex);
g_mutex_unlock (gmem_profile_mutex);
g_print ("GLib Memory statistics (successful operations):\n");
profile_print_locked (local_data, TRUE);
@ -432,11 +401,6 @@ g_mem_profile (void)
local_frees,
((gdouble) local_frees) / local_allocs * 100.0,
local_allocs - local_frees);
g_print ("MemChunk bytes: allocated=%lu, freed=%lu (%.2f%%), remaining=%lu\n",
local_mc_allocs,
local_mc_frees,
((gdouble) local_mc_frees) / local_mc_allocs * 100.0,
local_mc_allocs - local_mc_frees);
}
static gpointer
@ -602,47 +566,6 @@ GMemVTable *glib_mem_profiler_table = &profiler_table;
#endif /* !G_DISABLE_CHECKS */
/* --- memory slices --- */
typedef struct {
gpointer dummy, next;
} MemSlice;
gpointer
g_slice_alloc (guint block_size)
{
return g_malloc (block_size);
}
gpointer
g_slice_alloc0 (guint block_size)
{
return g_malloc0 (block_size);
}
void
g_slice_free1 (guint block_size,
gpointer mem_block)
{
if (mem_block)
g_free (mem_block);
}
void
g_slice_free_chain (guint block_size,
gpointer mem_chain,
guint next_offset)
{
MemSlice *slice = mem_chain;
g_return_if_fail (next_offset == G_STRUCT_OFFSET (MemSlice, next));
g_return_if_fail (block_size >= sizeof (MemSlice));
while (slice)
{
MemSlice *current = slice;
slice = slice->next;
g_slice_free1 (block_size, current);
}
}
/* --- MemChunks --- */
#ifndef G_ALLOC_AND_FREE
typedef struct _GAllocator GAllocator;
@ -651,63 +574,10 @@ typedef struct _GMemChunk GMemChunk;
#define G_ALLOC_AND_FREE 2
#endif
typedef struct _GFreeAtom GFreeAtom;
typedef struct _GMemArea GMemArea;
struct _GFreeAtom
{
GFreeAtom *next;
struct _GMemChunk {
guint alloc_size; /* the size of an atom */
};
struct _GMemArea
{
GMemArea *next; /* the next mem area */
GMemArea *prev; /* the previous mem area */
gulong index; /* the current index into the "mem" array */
gulong free; /* the number of free bytes in this mem area */
gulong allocated; /* the number of atoms allocated from this area */
gulong mark; /* is this mem area marked for deletion */
gchar mem[MEM_AREA_SIZE]; /* the mem array from which atoms get allocated
* the actual size of this array is determined by
* the mem chunk "area_size". ANSI says that it
* must be declared to be the maximum size it
* can possibly be (even though the actual size
* may be less).
*/
};
struct _GMemChunk
{
const gchar *name; /* name of this MemChunk...used for debugging output */
gint type; /* the type of MemChunk: ALLOC_ONLY or ALLOC_AND_FREE */
gint num_mem_areas; /* the number of memory areas */
gint num_marked_areas; /* the number of areas marked for deletion */
guint atom_size; /* the size of an atom */
gulong area_size; /* the size of a memory area */
GMemArea *mem_area; /* the current memory area */
GMemArea *mem_areas; /* a list of all the mem areas owned by this chunk */
GMemArea *free_mem_area; /* the free area...which is about to be destroyed */
GFreeAtom *free_atoms; /* the free atoms list */
GTree *mem_tree; /* tree of mem areas sorted by memory address */
GMemChunk *next; /* pointer to the next chunk */
GMemChunk *prev; /* pointer to the previous chunk */
};
#ifndef DISABLE_MEM_POOLS
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 GMemChunk *mem_chunks = NULL;
GMemChunk*
g_mem_chunk_new (const gchar *name,
gint atom_size,
@ -715,537 +585,35 @@ g_mem_chunk_new (const gchar *name,
gint type)
{
GMemChunk *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 (GMemChunk, 1);
mem_chunk->name = name;
mem_chunk->type = type;
mem_chunk->num_mem_areas = 0;
mem_chunk->num_marked_areas = 0;
mem_chunk->mem_area = NULL;
mem_chunk->free_mem_area = NULL;
mem_chunk->free_atoms = NULL;
mem_chunk->mem_tree = NULL;
mem_chunk->mem_areas = NULL;
mem_chunk->atom_size = atom_size;
if (mem_chunk->type == G_ALLOC_AND_FREE)
mem_chunk->mem_tree = g_tree_new ((GCompareFunc) g_mem_chunk_area_compare);
if (mem_chunk->atom_size % G_MEM_ALIGN)
mem_chunk->atom_size += G_MEM_ALIGN - (mem_chunk->atom_size % G_MEM_ALIGN);
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);
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 ();
mem_chunk = g_slice_new (GMemChunk);
mem_chunk->alloc_size = atom_size;
return mem_chunk;
}
void
g_mem_chunk_destroy (GMemChunk *mem_chunk)
{
GMemArea *mem_areas;
GMemArea *temp_area;
g_return_if_fail (mem_chunk != NULL);
ENTER_MEM_CHUNK_ROUTINE ();
mem_areas = mem_chunk->mem_areas;
while (mem_areas)
{
temp_area = mem_areas;
mem_areas = mem_areas->next;
g_free (temp_area);
}
g_mutex_lock (mem_chunks_lock);
if (mem_chunk->next)
mem_chunk->next->prev = mem_chunk->prev;
if (mem_chunk->prev)
mem_chunk->prev->next = mem_chunk->next;
if (mem_chunk == mem_chunks)
mem_chunks = mem_chunks->next;
g_mutex_unlock (mem_chunks_lock);
if (mem_chunk->type == G_ALLOC_AND_FREE)
g_tree_destroy (mem_chunk->mem_tree);
g_free (mem_chunk);
LEAVE_MEM_CHUNK_ROUTINE ();
g_slice_free (GMemChunk, mem_chunk);
}
gpointer
g_mem_chunk_alloc (GMemChunk *mem_chunk)
{
GMemArea *temp_area;
gpointer mem;
ENTER_MEM_CHUNK_ROUTINE ();
g_return_val_if_fail (mem_chunk != NULL, NULL);
while (mem_chunk->free_atoms)
{
/* Get the first piece of memory on the "free_atoms" list.
* We can go ahead and destroy the list node we used to keep
* track of it with and to update the "free_atoms" list to
* point to its next element.
*/
mem = mem_chunk->free_atoms;
mem_chunk->free_atoms = mem_chunk->free_atoms->next;
/* Determine which area this piece of memory is allocated from */
temp_area = g_tree_search (mem_chunk->mem_tree,
(GCompareFunc) g_mem_chunk_area_search,
mem);
/* If the area has been marked, then it is being destroyed.
* (ie marked to be destroyed).
* We check to see if all of the segments on the free list that
* reference this area have been removed. This occurs when
* the ammount of free memory is less than the allocatable size.
* If the chunk should be freed, then we place it in the "free_mem_area".
* This is so we make sure not to free the mem area here and then
* allocate it again a few lines down.
* If we don't allocate a chunk a few lines down then the "free_mem_area"
* will be freed.
* If there is already a "free_mem_area" then we'll just free this mem area.
*/
if (temp_area->mark)
{
/* Update the "free" memory available in that area */
temp_area->free += mem_chunk->atom_size;
if (temp_area->free == mem_chunk->area_size)
{
if (temp_area == mem_chunk->mem_area)
mem_chunk->mem_area = NULL;
if (mem_chunk->free_mem_area)
{
mem_chunk->num_mem_areas -= 1;
if (temp_area->next)
temp_area->next->prev = temp_area->prev;
if (temp_area->prev)
temp_area->prev->next = temp_area->next;
if (temp_area == mem_chunk->mem_areas)
mem_chunk->mem_areas = mem_chunk->mem_areas->next;
if (mem_chunk->type == G_ALLOC_AND_FREE)
g_tree_remove (mem_chunk->mem_tree, temp_area);
g_free (temp_area);
}
else
mem_chunk->free_mem_area = temp_area;
mem_chunk->num_marked_areas -= 1;
}
}
else
{
/* Update the number of allocated atoms count.
*/
temp_area->allocated += 1;
/* The area wasn't marked...return the memory
*/
goto outa_here;
}
}
/* If there isn't a current mem area or the current mem area is out of space
* then allocate a new mem area. We'll first check and see if we can use
* the "free_mem_area". Otherwise we'll just malloc the mem area.
*/
if ((!mem_chunk->mem_area) ||
((mem_chunk->mem_area->index + mem_chunk->atom_size) > mem_chunk->area_size))
{
if (mem_chunk->free_mem_area)
{
mem_chunk->mem_area = mem_chunk->free_mem_area;
mem_chunk->free_mem_area = NULL;
}
else
{
#ifdef ENABLE_GC_FRIENDLY
mem_chunk->mem_area = (GMemArea*) g_malloc0 (sizeof (GMemArea) -
MEM_AREA_SIZE +
mem_chunk->area_size);
#else /* !ENABLE_GC_FRIENDLY */
mem_chunk->mem_area = (GMemArea*) g_malloc (sizeof (GMemArea) -
MEM_AREA_SIZE +
mem_chunk->area_size);
#endif /* ENABLE_GC_FRIENDLY */
mem_chunk->num_mem_areas += 1;
mem_chunk->mem_area->next = mem_chunk->mem_areas;
mem_chunk->mem_area->prev = NULL;
if (mem_chunk->mem_areas)
mem_chunk->mem_areas->prev = mem_chunk->mem_area;
mem_chunk->mem_areas = mem_chunk->mem_area;
if (mem_chunk->type == G_ALLOC_AND_FREE)
g_tree_insert (mem_chunk->mem_tree, mem_chunk->mem_area, mem_chunk->mem_area);
}
mem_chunk->mem_area->index = 0;
mem_chunk->mem_area->free = mem_chunk->area_size;
mem_chunk->mem_area->allocated = 0;
mem_chunk->mem_area->mark = 0;
}
/* Get the memory and modify the state variables appropriately.
*/
mem = (gpointer) &mem_chunk->mem_area->mem[mem_chunk->mem_area->index];
mem_chunk->mem_area->index += mem_chunk->atom_size;
mem_chunk->mem_area->free -= mem_chunk->atom_size;
mem_chunk->mem_area->allocated += 1;
outa_here:
LEAVE_MEM_CHUNK_ROUTINE ();
return mem;
return g_slice_alloc (mem_chunk->alloc_size);
}
gpointer
g_mem_chunk_alloc0 (GMemChunk *mem_chunk)
{
gpointer mem;
mem = g_mem_chunk_alloc (mem_chunk);
if (mem)
{
memset (mem, 0, mem_chunk->atom_size);
}
return mem;
}
void
g_mem_chunk_free (GMemChunk *mem_chunk,
gpointer mem)
{
GMemArea *temp_area;
GFreeAtom *free_atom;
g_return_if_fail (mem_chunk != NULL);
g_return_if_fail (mem != NULL);
ENTER_MEM_CHUNK_ROUTINE ();
#ifdef ENABLE_GC_FRIENDLY
memset (mem, 0, mem_chunk->atom_size);
#endif /* ENABLE_GC_FRIENDLY */
/* Don't do anything if this is an ALLOC_ONLY chunk
*/
if (mem_chunk->type == G_ALLOC_AND_FREE)
{
/* Place the memory on the "free_atoms" list
*/
free_atom = (GFreeAtom*) mem;
free_atom->next = mem_chunk->free_atoms;
mem_chunk->free_atoms = free_atom;
temp_area = g_tree_search (mem_chunk->mem_tree,
(GCompareFunc) g_mem_chunk_area_search,
mem);
temp_area->allocated -= 1;
if (temp_area->allocated == 0)
{
temp_area->mark = 1;
mem_chunk->num_marked_areas += 1;
}
}
LEAVE_MEM_CHUNK_ROUTINE ();
}
/* This doesn't free the free_area if there is one */
void
g_mem_chunk_clean (GMemChunk *mem_chunk)
{
GMemArea *mem_area;
GFreeAtom *prev_free_atom;
GFreeAtom *temp_free_atom;
gpointer mem;
g_return_if_fail (mem_chunk != NULL);
ENTER_MEM_CHUNK_ROUTINE ();
if (mem_chunk->type == G_ALLOC_AND_FREE)
{
prev_free_atom = NULL;
temp_free_atom = mem_chunk->free_atoms;
while (temp_free_atom)
{
mem = (gpointer) temp_free_atom;
mem_area = g_tree_search (mem_chunk->mem_tree,
(GCompareFunc) g_mem_chunk_area_search,
mem);
/* If this mem area is marked for destruction then delete the
* area and list node and decrement the free mem.
*/
if (mem_area->mark)
{
if (prev_free_atom)
prev_free_atom->next = temp_free_atom->next;
else
mem_chunk->free_atoms = temp_free_atom->next;
temp_free_atom = temp_free_atom->next;
mem_area->free += mem_chunk->atom_size;
if (mem_area->free == mem_chunk->area_size)
{
mem_chunk->num_mem_areas -= 1;
mem_chunk->num_marked_areas -= 1;
if (mem_area->next)
mem_area->next->prev = mem_area->prev;
if (mem_area->prev)
mem_area->prev->next = mem_area->next;
if (mem_area == mem_chunk->mem_areas)
mem_chunk->mem_areas = mem_chunk->mem_areas->next;
if (mem_area == mem_chunk->mem_area)
mem_chunk->mem_area = NULL;
if (mem_chunk->type == G_ALLOC_AND_FREE)
g_tree_remove (mem_chunk->mem_tree, mem_area);
g_free (mem_area);
}
}
else
{
prev_free_atom = temp_free_atom;
temp_free_atom = temp_free_atom->next;
}
}
}
LEAVE_MEM_CHUNK_ROUTINE ();
}
void
g_mem_chunk_reset (GMemChunk *mem_chunk)
{
GMemArea *mem_areas;
GMemArea *temp_area;
g_return_if_fail (mem_chunk != NULL);
ENTER_MEM_CHUNK_ROUTINE ();
mem_areas = mem_chunk->mem_areas;
mem_chunk->num_mem_areas = 0;
mem_chunk->mem_areas = NULL;
mem_chunk->mem_area = NULL;
while (mem_areas)
{
temp_area = mem_areas;
mem_areas = mem_areas->next;
g_free (temp_area);
}
mem_chunk->free_atoms = NULL;
if (mem_chunk->mem_tree)
{
g_tree_destroy (mem_chunk->mem_tree);
mem_chunk->mem_tree = g_tree_new ((GCompareFunc) g_mem_chunk_area_compare);
}
LEAVE_MEM_CHUNK_ROUTINE ();
}
void
g_mem_chunk_print (GMemChunk *mem_chunk)
{
GMemArea *mem_areas;
gulong mem;
g_return_if_fail (mem_chunk != NULL);
mem_areas = mem_chunk->mem_areas;
mem = 0;
while (mem_areas)
{
mem += mem_chunk->area_size - mem_areas->free;
mem_areas = mem_areas->next;
}
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO,
"%s: %ld bytes using %d mem areas",
mem_chunk->name, mem, mem_chunk->num_mem_areas);
}
void
g_mem_chunk_info (void)
{
GMemChunk *mem_chunk;
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, 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
g_blow_chunks (void)
{
GMemChunk *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);
mem_chunk = mem_chunk->next;
}
}
static gulong
g_mem_chunk_compute_size (gulong size,
gulong min_size)
{
gulong power_of_2;
gulong lower, upper;
power_of_2 = 16;
while (power_of_2 < size)
power_of_2 <<= 1;
lower = power_of_2 >> 1;
upper = power_of_2;
if (size - lower < upper - size && lower >= min_size)
return lower;
else
return upper;
}
static gint
g_mem_chunk_area_compare (GMemArea *a,
GMemArea *b)
{
if (a->mem > b->mem)
return 1;
else if (a->mem < b->mem)
return -1;
return 0;
}
static gint
g_mem_chunk_area_search (GMemArea *a,
gchar *addr)
{
if (a->mem <= addr)
{
if (addr < &a->mem[a->index])
return 0;
return 1;
}
return -1;
}
#else /* DISABLE_MEM_POOLS */
typedef struct {
guint alloc_size; /* the size of an atom */
} GMinimalMemChunk;
GMemChunk*
g_mem_chunk_new (const gchar *name,
gint atom_size,
gulong area_size,
gint type)
{
GMinimalMemChunk *mem_chunk;
g_return_val_if_fail (atom_size > 0, NULL);
mem_chunk = g_new (GMinimalMemChunk, 1);
mem_chunk->alloc_size = atom_size;
return ((GMemChunk*) mem_chunk);
}
void
g_mem_chunk_destroy (GMemChunk *mem_chunk)
{
g_return_if_fail (mem_chunk != NULL);
g_free (mem_chunk);
}
gpointer
g_mem_chunk_alloc (GMemChunk *mem_chunk)
{
GMinimalMemChunk *minimal = (GMinimalMemChunk *)mem_chunk;
g_return_val_if_fail (mem_chunk != NULL, NULL);
return g_malloc (minimal->alloc_size);
}
gpointer
g_mem_chunk_alloc0 (GMemChunk *mem_chunk)
{
GMinimalMemChunk *minimal = (GMinimalMemChunk *)mem_chunk;
g_return_val_if_fail (mem_chunk != NULL, NULL);
return g_malloc0 (minimal->alloc_size);
return g_slice_alloc0 (mem_chunk->alloc_size);
}
void
@ -1254,7 +622,7 @@ g_mem_chunk_free (GMemChunk *mem_chunk,
{
g_return_if_fail (mem_chunk != NULL);
g_free (mem);
g_slice_free1 (mem_chunk->alloc_size, mem);
}
void g_mem_chunk_clean (GMemChunk *mem_chunk) {}
@ -1263,28 +631,23 @@ void g_mem_chunk_print (GMemChunk *mem_chunk) {}
void g_mem_chunk_info (void) {}
void g_blow_chunks (void) {}
#endif /* DISABLE_MEM_POOLS */
struct _GAllocator
{
gchar *name;
guint16 n_preallocs;
guint is_unused : 1;
guint type : 4;
GAllocator *last;
GMemChunk *mem_chunk;
gpointer free_list;
};
GAllocator*
g_allocator_new (const gchar *name,
guint n_preallocs)
{
static const GAllocator dummy = {
static const 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 (GAllocator*) &dummy;
return (void*) &dummy;
}
void
@ -1293,22 +656,13 @@ g_allocator_free (GAllocator *allocator)
}
void
_g_mem_thread_init (void)
_g_mem_thread_init_noprivate_nomessage (void)
{
#ifndef DISABLE_MEM_POOLS
mem_chunks_lock = g_mutex_new ();
#endif
/* we may only create mutexes here, locking/unlocking itself
* does not yet work.
*/
#ifndef G_DISABLE_CHECKS
g_profile_mutex = g_mutex_new ();
#endif
}
void
_g_mem_thread_private_init (void)
{
#ifndef G_DISABLE_CHECKS
g_assert (mem_chunk_recursion == NULL);
mem_chunk_recursion = g_private_new (NULL);
gmem_profile_mutex = g_mutex_new ();
#endif
}

14
glib/gmem.h
View File

@ -27,6 +27,7 @@
#ifndef __G_MEM_H__
#define __G_MEM_H__
#include <glib/gslice.h>
#include <glib/gtypes.h>
G_BEGIN_DECLS
@ -96,19 +97,6 @@ gboolean g_mem_is_system_malloc (void);
GLIB_VAR GMemVTable *glib_mem_profiler_table;
void g_mem_profile (void);
/* slices - fast allocation/release of small memory blocks
*/
gpointer g_slice_alloc (guint block_size);
gpointer g_slice_alloc0 (guint block_size);
void g_slice_free1 (guint block_size,
gpointer mem_block);
void g_slice_free_chain (guint block_size,
gpointer mem_chain,
guint next_offset);
#define g_slice_new(type) ((type*) g_slice_alloc (sizeof (type)))
#define g_slice_new0(type) ((type*) g_slice_alloc0 (sizeof (type)))
#define g_slice_free(type,mem) g_slice_free1 (sizeof (type), mem)
/* deprecated memchunks and allocators */
#if !defined G_DISABLE_DEPRECATED || 1

10
glib/gmessages.c
View File

@ -1041,20 +1041,14 @@ g_printf_string_upper_bound (const gchar *format,
}
void
_g_messages_thread_init (void)
_g_messages_thread_init_nomessage (void)
{
g_messages_lock = g_mutex_new ();
g_log_depth = g_private_new (NULL);
g_messages_prefixed_init ();
_g_debug_init ();
}
void
_g_messages_thread_private_init (void)
{
g_assert (g_log_depth == NULL);
g_log_depth = g_private_new (NULL);
}
gboolean _g_debug_initialized = FALSE;
guint _g_debug_flags = 0;

983
glib/gslice.c Normal file
View File

@ -0,0 +1,983 @@
/* GLIB sliced memory - fast concurrent memory chunk allocator
* Copyright (C) 2005 Tim Janik
*
* This library 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 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
* 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.
*/
/* MT safe */
#define _XOPEN_SOURCE 600 /* posix_memalign() */
#include <stdlib.h> /* posix_memalign() */
#include <unistd.h> /* sysconf() */
#include <assert.h> /* assert() for nomessage phase */
#include <string.h>
#include <errno.h>
#include "config.h"
#include "gmem.h" /* gslice.h */
#include "gthreadinit.h"
#include "galias.h"
#include "glib.h"
/* the GSlice allocator is split up into 4 layers, roughly modelled after the slab
* allocator and magazine extensions as outlined in:
* + [Bonwick94] Jeff Bonwick, The slab allocator: An object-caching kernel
* memory allocator. USENIX 1994, http://citeseer.ist.psu.edu/bonwick94slab.html
* + [Bonwick01] Bonwick and Jonathan Adams, Magazines and vmem: Extending the
* slab allocator to many cpu's and arbitrary resources.
* USENIX 2001, http://citeseer.ist.psu.edu/bonwick01magazines.html
* the layers are:
* - the thread magazines. for each (aligned) chunk size, a magazine (a list)
* of recently freed and soon to be allocated chunks is maintained per thread.
* this way, most alloc/free requests can be quickly satisfied from per-thread
* free lists which only require one g_private_get() call to retrive the
* thread handle.
* - the magazine cache. allocating and freeing chunks to/from threads only
* occours at magazine sizes from a global depot of magazines. the depot
* maintaines a 15 second working set of allocated magazines, so full
* magazines are not allocated and released too often.
* the chunk size dependent magazine sizes automatically adapt (within limits,
* see [3]) to lock contention to properly scale performance across a variety
* of SMP systems.
* - the slab allocator. this allocator allocates slabs (blocks of memory) close
* to the system page size or multiples thereof which have to be page aligned.
* the blocks are divided into smaller chunks which are used to satisfy
* allocations from the upper layers. the space provided by the reminder of
* the chunk size division is used for cache colorization (random distribution
* of chunk addresses) to improve processor cache utilization. multiple slabs
* with the same chunk size are kept in a partially sorted ring to allow O(1)
* freeing and allocation of chunks (as long as the allocation of an entirely
* new slab can be avoided).
* - the page allocator. on most modern systems, posix_memalign(3) or
* memalign(3) should be available, so this is used to allocate blocks with
* system page size based alignments and sizes or multiples thereof.
* if no memalign variant is provided, valloc() is used instead and
* block sizes are limited to the system page size (no multiples thereof).
* as a fallback, on system without even valloc(), a malloc(3)-based page
* allocator with alloc-only behaviour is used.
*
* NOTES:
* [1] some systems memalign(3) implementations may rely on boundary tagging for
* the handed out memory chunks. to avoid excessive page-wise fragmentation,
* we reserve 2 * sizeof (void*) per block size for the systems memalign(3),
* specified in NATIVE_MALLOC_PADDING.
* [2] using the slab allocator alone already provides for a fast and efficient
* allocator, it doesn't properly scale beyond single-threaded uses though.
* also, the slab allocator implements eager free(3)-ing, i.e. does not
* provide any form of caching or working set maintenance. so if used alone,
* it's vulnerable to trashing for sequences of balanced (alloc, free) pairs
* at certain thresholds.
* [3] magazine sizes are bound by an implementation specific minimum size and
* a chunk size specific maximum to limit magazine storage sizes to roughly
* 16KB.
* [4] allocating ca. 8 chunks per block/page keeps a good balance between
* external and internal fragmentation (<= 12.5%) [Bonwick94]
*/
/* --- macros and constants --- */
#define LARGEALIGNMENT (256)
#define P2ALIGNMENT (2 * sizeof (gsize)) /* fits 2 pointers (assumed to be 2 * GLIB_SIZEOF_SIZE_T below) */
#define ALIGN(size, base) ((base) * (gsize) (((size) + (base) - 1) / (base)))
#define NATIVE_MALLOC_PADDING P2ALIGNMENT /* per-page padding left for native malloc(3) see [1] */
#define SLAB_INFO_SIZE P2ALIGN (sizeof (SlabInfo) + NATIVE_MALLOC_PADDING)
#define MAX_MAGAZINE_SIZE (256) /* see [3] and allocator_get_magazine_threshold() for this */
#define MIN_MAGAZINE_SIZE (4)
#define MAX_STAMP_COUNTER (13) /* distributes the load of gettimeofday() */
#define MAX_SLAB_CHUNK_SIZE(al) (((al)->max_page_size - SLAB_INFO_SIZE) / 8) /* we want at last 8 chunks per page, see [4] */
#define MAX_SLAB_INDEX(al) (SLAB_INDEX (al, MAX_SLAB_CHUNK_SIZE (al)) + 1)
#define SLAB_INDEX(al, asize) ((asize) / P2ALIGNMENT - 1) /* asize must be P2ALIGNMENT aligned */
#define SLAB_CHUNK_SIZE(al, ix) (((ix) + 1) * P2ALIGNMENT)
#define SLAB_PAGE_SIZE(al,csz) (ALIGN (8 * (csz) + SLAB_INFO_SIZE, (al)->min_page_size))
/* optimized version of ALIGN (size, P2ALIGNMENT) */
#if GLIB_SIZEOF_SIZE_T * 2 == 8 /* P2ALIGNMENT */
#define P2ALIGN(size) (((size) + 0x7) & ~(gsize) 0x7)
#elif GLIB_SIZEOF_SIZE_T * 2 == 16 /* P2ALIGNMENT */
#define P2ALIGN(size) (((size) + 0xf) & ~(gsize) 0xf)
#else
#define P2ALIGN(size) ALIGN (size, P2ALIGNMENT)
#endif
/* --- structures --- */
typedef struct _ChunkLink ChunkLink;
typedef struct _SlabInfo SlabInfo;
typedef struct _CachedMagazine CachedMagazine;
struct _ChunkLink {
ChunkLink *next;
ChunkLink *data;
};
struct _SlabInfo {
ChunkLink *chunks;
guint n_allocated;
SlabInfo *next, *prev;
};
typedef struct {
ChunkLink *chunks;
gsize count; /* approximative chunks list length */
} Magazine;
typedef struct {
Magazine *magazine1; /* array of MAX_SLAB_INDEX (allocator) */
Magazine *magazine2; /* array of MAX_SLAB_INDEX (allocator) */
} ThreadMemory;
typedef struct {
gboolean always_malloc;
gboolean bypass_magazines;
gboolean always_free;
gsize working_set_msecs;
} SliceConfig;
typedef struct {
/* const after initialization */
gsize min_page_size, max_page_size;
SliceConfig config;
guint max_slab_chunk_size_for_magazine_cache;
/* magazine cache */
GMutex *magazine_mutex;
ChunkLink **magazines; /* array of MAX_SLAB_INDEX (allocator) */
guint *contention_counters; /* array of MAX_SLAB_INDEX (allocator) */
gint mutex_counter;
guint stamp_counter;
guint last_stamp;
/* slab allocator */
GMutex *slab_mutex;
SlabInfo **slab_stack; /* array of MAX_SLAB_INDEX (allocator) */
guint color_accu;
} Allocator;
/* --- prototypes --- */
static gpointer slab_allocator_alloc_chunk (guint chunk_size);
static void slab_allocator_free_chunk (guint chunk_size,
gpointer mem);
static void private_thread_memory_cleanup (gpointer data);
static gpointer allocator_memalign (gsize alignment,
gsize memsize);
static void allocator_memfree (gsize memsize,
gpointer mem);
static inline void magazine_cache_update_stamp (void);
static inline guint allocator_get_magazine_threshold (Allocator *allocator,
guint ix);
/* --- variables --- */
static GPrivate *private_thread_memory = NULL;
static gsize sys_page_size = 0;
static Allocator allocator[1] = { { 0, }, };
static SliceConfig slice_config = {
FALSE, /* always_malloc */
FALSE, /* bypass_magazines */
FALSE, /* always_free */
15 * 1000, /* working_set_msecs */
};
/* --- auxillary funcitons --- */
void
g_slice_set_config (GSliceConfig ckey,
gint64 value)
{
g_return_if_fail (sys_page_size == 0);
switch (ckey)
{
case G_SLICE_CONFIG_ALWAYS_MALLOC:
slice_config.always_malloc = value != 0;
break;
case G_SLICE_CONFIG_BYPASS_MAGAZINES:
slice_config.bypass_magazines = value != 0;
break;
case G_SLICE_CONFIG_ALWAYS_FREE:
slice_config.always_free = value != 0;
break;
case G_SLICE_CONFIG_WORKING_SET_MSECS:
slice_config.working_set_msecs = value;
break;
default: ;
}
}
gint64
g_slice_get_config (GSliceConfig ckey)
{
switch (ckey)
{
case G_SLICE_CONFIG_ALWAYS_MALLOC:
return slice_config.always_malloc;
case G_SLICE_CONFIG_BYPASS_MAGAZINES:
return slice_config.bypass_magazines;
case G_SLICE_CONFIG_ALWAYS_FREE:
return slice_config.always_free;
case G_SLICE_CONFIG_WORKING_SET_MSECS:
return slice_config.working_set_msecs;
case G_SLICE_CONFIG_CHUNK_SIZES:
return MAX_SLAB_INDEX (allocator);
default:
return 0;
}
}
gint64*
g_slice_get_config_state (GSliceConfig ckey,
gint64 address,
guint *n_values)
{
guint i = 0;
g_return_val_if_fail (n_values != NULL, NULL);
*n_values = 0;
switch (ckey)
{
gint64 array[64];
case G_SLICE_CONFIG_CONTENTION_COUNTER:
array[i++] = SLAB_CHUNK_SIZE (allocator, address);
array[i++] = allocator->contention_counters[address];
array[i++] = allocator_get_magazine_threshold (allocator, address);
*n_values = i;
return g_memdup (array, sizeof (array[0]) * *n_values);
default:
return NULL;
}
}
static void
g_slice_init_nomessage (void)
{
/* we may not use g_error() or friends here */
assert (sys_page_size == 0);
sys_page_size = sysconf (_SC_PAGESIZE); /* = sysconf (_SC_PAGE_SIZE); = getpagesize(); */
assert (sys_page_size >= 2 * LARGEALIGNMENT);
allocator->config = slice_config;
allocator->min_page_size = sys_page_size;
#if HAVE_POSIX_MEMALIGN || HAVE_MEMALIGN
/* allow allocation of pages up to 8KB (with 8KB alignment).
* this is useful because many medium to large sized structures
* fit less than 8 times (see [4]) into 4KB pages.
*/
allocator->min_page_size = MAX (allocator->min_page_size, 4096);
allocator->max_page_size = MAX (allocator->min_page_size, 8192);
#else
/* we can only align to system page size */
allocator->max_page_size = sys_page_size;
#endif
allocator->magazine_mutex = NULL; /* _g_slice_thread_init_nomessage() */
allocator->magazines = g_new0 (ChunkLink*, MAX_SLAB_INDEX (allocator));
allocator->contention_counters = g_new0 (guint, MAX_SLAB_INDEX (allocator));
allocator->mutex_counter = 0;
allocator->stamp_counter = MAX_STAMP_COUNTER; /* force initial update */
allocator->last_stamp = 0;
allocator->slab_mutex = NULL; /* _g_slice_thread_init_nomessage() */
allocator->slab_stack = g_new0 (SlabInfo*, MAX_SLAB_INDEX (allocator));
allocator->color_accu = 0;
magazine_cache_update_stamp();
/* values cached for performance reasons */
allocator->max_slab_chunk_size_for_magazine_cache = MAX_SLAB_CHUNK_SIZE (allocator);
if (allocator->config.always_malloc || allocator->config.bypass_magazines)
allocator->max_slab_chunk_size_for_magazine_cache = 0; /* non-optimized cases */
}
static inline guint
allocator_categorize (guint aligned_chunk_size)
{
/* speed up the likely path */
if (G_LIKELY (aligned_chunk_size && aligned_chunk_size <= allocator->max_slab_chunk_size_for_magazine_cache))
return 1; /* use magazine cache */
/* the above will fail (max_slab_chunk_size_for_magazine_cache == 0) if the
* allocator is still uninitialized, or if we are not configured to use the
* magazine cache.
*/
if (!sys_page_size)
g_slice_init_nomessage ();
if (!allocator->config.always_malloc &&
aligned_chunk_size &&
aligned_chunk_size <= MAX_SLAB_CHUNK_SIZE (allocator))
{
if (allocator->config.bypass_magazines)
return 2; /* use slab allocator, see [2] */
return 1; /* use magazine cache */
}
return 0; /* use malloc() */
}
void
_g_slice_thread_init_nomessage (void)
{
/* we may not use g_error() or friends here */
if (!sys_page_size)
g_slice_init_nomessage();
private_thread_memory = g_private_new (private_thread_memory_cleanup);
allocator->magazine_mutex = g_mutex_new();
allocator->slab_mutex = g_mutex_new();
}
static inline void
g_mutex_lock_a (GMutex *mutex,
guint *threshold)
{
gboolean contention = FALSE;
if (!g_mutex_trylock (mutex))
{
g_mutex_lock (mutex);
contention = TRUE;
}
if (contention)
{
allocator->mutex_counter++;
if (allocator->mutex_counter >= 1) /* quickly adapt to contention */
{
allocator->mutex_counter = 0;
*threshold = MIN (*threshold + 1, MAX_MAGAZINE_SIZE);
}
}
else /* !contention */
{
allocator->mutex_counter--;
if (allocator->mutex_counter < -11) /* moderately recover magazine sizes */
{
allocator->mutex_counter = 0;
*threshold = MAX (*threshold, 1) - 1;
}
}
}
static inline ThreadMemory*
thread_memory_from_self (void)
{
ThreadMemory *tmem = g_private_get (private_thread_memory);
if (G_UNLIKELY (!tmem))
{
const guint n_magazines = MAX_SLAB_INDEX (allocator);
tmem = g_malloc0 (sizeof (ThreadMemory) + sizeof (Magazine) * 2 * n_magazines);
tmem->magazine1 = (Magazine*) (tmem + 1);
tmem->magazine2 = &tmem->magazine1[n_magazines];
g_private_set (private_thread_memory, tmem);
}
return tmem;
}
static inline ChunkLink*
magazine_chain_pop_head (ChunkLink **magazine_chunks)
{
/* magazine chains are linked via ChunkLink->next.
* each ChunkLink->data of the toplevel chain may point to a subchain,
* linked via ChunkLink->next. ChunkLink->data of the subchains just
* contains uninitialized junk.
*/
ChunkLink *chunk = (*magazine_chunks)->data;
if (G_UNLIKELY (chunk))
{
/* allocating from freed list */
(*magazine_chunks)->data = chunk->next;
}
else
{
chunk = *magazine_chunks;
*magazine_chunks = chunk->next;
}
return chunk;
}
static guint
magazine_count (ChunkLink *head)
{
guint count = 0;
if (!head)
return 0;
while (head)
{
ChunkLink *child = head->data;
count += 1;
for (child = head->data; child; child = child->next)
count += 1;
head = head->next;
}
return count;
}
static inline guint
allocator_get_magazine_threshold (Allocator *allocator,
guint ix)
{
/* the magazine size calculated here has a lower bound of MIN_MAGAZINE_SIZE,
* which is required by the implementation. also, for moderately sized chunks
* (say >= 64 bytes), magazine sizes shouldn't be much smaller then the number
* of chunks available per page to avoid excessive traffic in the magazine
* cache for small to medium sized structures.
* the upper bound of the magazine size is effectively provided by
* MAX_MAGAZINE_SIZE. for larger chunks, this number is scaled down so that
* the content of a single magazine doesn't exceed ca. 16KB.
*/
guint chunk_size = SLAB_CHUNK_SIZE (allocator, ix);
guint threshold = MAX (MIN_MAGAZINE_SIZE, sys_page_size / MAX (chunk_size, 64));
guint contention_counter = allocator->contention_counters[ix];
if (G_UNLIKELY (contention_counter)) /* single CPU bias */
{
/* adapt contention counter thresholds to chunk sizes */
contention_counter = contention_counter * 64 / chunk_size;
threshold = MAX (threshold, contention_counter);
}
return threshold;
}
/* --- magazine cache --- */
static inline void
magazine_cache_update_stamp (void)
{
if (allocator->stamp_counter >= MAX_STAMP_COUNTER)
{
GTimeVal tv;
g_get_current_time (&tv);
allocator->last_stamp = tv.tv_sec * 1000 + tv.tv_usec / 1000; /* milli seconds */
allocator->stamp_counter = 0;
}
else
allocator->stamp_counter++;
}
static inline ChunkLink*
magazine_chain_prepare_fields (ChunkLink *magazine_chunks)
{
g_assert (MIN_MAGAZINE_SIZE >= 4);
/* ensure a magazine with at least 4 unused data pointers */
ChunkLink *chunk1 = magazine_chain_pop_head (&magazine_chunks);
ChunkLink *chunk2 = magazine_chain_pop_head (&magazine_chunks);
ChunkLink *chunk3 = magazine_chain_pop_head (&magazine_chunks);
ChunkLink *chunk4 = magazine_chain_pop_head (&magazine_chunks);
chunk4->next = magazine_chunks;
chunk3->next = chunk4;
chunk2->next = chunk3;
chunk1->next = chunk2;
return chunk1;
}
/* access the first 3 fields of a specially prepared magazine chain */
#define magazine_chain_prev(mc) ((mc)->data)
#define magazine_chain_stamp(mc) ((mc)->next->data)
#define magazine_chain_next(mc) ((mc)->next->next->data)
#define magazine_chain_count(mc) ((mc)->next->next->next->data)
static void
magazine_cache_trim (Allocator *allocator,
guint ix,
guint stamp)
{
/* g_mutex_lock (allocator->mutex); done by caller */
/* trim magazine cache from tail */
ChunkLink *current = magazine_chain_prev (allocator->magazines[ix]);
ChunkLink *trash = NULL;
while (allocator->config.always_free ||
ABS (stamp - (guint) magazine_chain_stamp (current)) > allocator->config.working_set_msecs)
{
/* unlink */
ChunkLink *prev = magazine_chain_prev (current);
ChunkLink *next = magazine_chain_next (current);
magazine_chain_next (prev) = next;
magazine_chain_prev (next) = prev;
/* clear special fields, put on trash stack */
magazine_chain_next (current) = NULL;
magazine_chain_count (current) = NULL;
magazine_chain_stamp (current) = NULL;
magazine_chain_prev (current) = trash;
trash = current;
/* fixup list head if required */
if (current == allocator->magazines[ix])
{
allocator->magazines[ix] = NULL;
break;
}
current = prev;
}
g_mutex_unlock (allocator->magazine_mutex);
/* free trash */
if (trash)
{
const guint chunk_size = SLAB_CHUNK_SIZE (allocator, ix);
g_mutex_lock (allocator->slab_mutex);
while (trash)
{
current = trash;
trash = magazine_chain_prev (current);
magazine_chain_prev (current) = NULL; /* clear special field */
while (current)
{
ChunkLink *chunk = magazine_chain_pop_head (&current);
slab_allocator_free_chunk (chunk_size, chunk);
}
}
g_mutex_unlock (allocator->slab_mutex);
}
}
static void
magazine_cache_push_magazine (guint ix,
ChunkLink *magazine_chunks,
gsize count) /* must be >= MIN_MAGAZINE_SIZE */
{
ChunkLink *current = magazine_chain_prepare_fields (magazine_chunks);
ChunkLink *next, *prev;
g_mutex_lock (allocator->magazine_mutex);
/* add magazine at head */
next = allocator->magazines[ix];
if (next)
prev = magazine_chain_prev (next);
else
next = prev = current;
magazine_chain_next (prev) = current;
magazine_chain_prev (next) = current;
magazine_chain_prev (current) = prev;
magazine_chain_next (current) = next;
magazine_chain_count (current) = (gpointer) count;
/* stamp magazine */
magazine_cache_update_stamp();
magazine_chain_stamp (current) = (gpointer) allocator->last_stamp;
allocator->magazines[ix] = current;
/* free old magazines beyond a certain threshold */
magazine_cache_trim (allocator, ix, allocator->last_stamp);
/* g_mutex_unlock (allocator->mutex); was done by magazine_cache_trim() */
}
static ChunkLink*
magazine_cache_pop_magazine (guint ix,
gsize *countp)
{
g_mutex_lock_a (allocator->magazine_mutex, &allocator->contention_counters[ix]);
if (!allocator->magazines[ix])
{
guint magazine_threshold = allocator_get_magazine_threshold (allocator, ix);
gsize i, chunk_size = SLAB_CHUNK_SIZE (allocator, ix);
ChunkLink *current = NULL;
g_mutex_unlock (allocator->magazine_mutex);
g_mutex_lock (allocator->slab_mutex);
for (i = 0; i < magazine_threshold; i++)
{
ChunkLink *chunk = slab_allocator_alloc_chunk (chunk_size);
chunk->data = NULL;
chunk->next = current;
current = chunk;
}
g_mutex_unlock (allocator->slab_mutex);
*countp = i;
return current;
}
else
{
ChunkLink *current = allocator->magazines[ix];
ChunkLink *prev = magazine_chain_prev (current);
ChunkLink *next = magazine_chain_next (current);
/* unlink */
magazine_chain_next (prev) = next;
magazine_chain_prev (next) = prev;
allocator->magazines[ix] = next == current ? NULL : next;
g_mutex_unlock (allocator->magazine_mutex);
/* clear special fields and hand out */
*countp = (gsize) magazine_chain_count (current);
magazine_chain_prev (current) = NULL;
magazine_chain_next (current) = NULL;
magazine_chain_count (current) = NULL;
magazine_chain_stamp (current) = NULL;
return current;
}
}
/* --- thread magazines --- */
static void
private_thread_memory_cleanup (gpointer data)
{
ThreadMemory *tmem = data;
const guint n_magazines = MAX_SLAB_INDEX (allocator);
guint ix;
for (ix = 0; ix < n_magazines; ix++)
{
Magazine *mags[2];
guint j;
mags[0] = &tmem->magazine1[ix];
mags[1] = &tmem->magazine2[ix];
for (j = 0; j < 2; j++)
{
Magazine *mag = mags[j];
if (mag->count >= MIN_MAGAZINE_SIZE)
magazine_cache_push_magazine (ix, mag->chunks, mag->count);
else
{
const guint chunk_size = SLAB_CHUNK_SIZE (allocator, ix);
g_mutex_lock (allocator->slab_mutex);
while (mag->chunks)
{
ChunkLink *chunk = magazine_chain_pop_head (&mag->chunks);
slab_allocator_free_chunk (chunk_size, chunk);
}
g_mutex_unlock (allocator->slab_mutex);
}
}
}
g_free (tmem);
}
static void
thread_memory_magazine1_reload (ThreadMemory *tmem,
guint ix)
{
Magazine *mag = &tmem->magazine1[ix];
g_assert (mag->chunks == NULL); /* ensure that we may reset mag->count */
mag->count = 0;
mag->chunks = magazine_cache_pop_magazine (ix, &mag->count);
}
static void
thread_memory_magazine2_unload (ThreadMemory *tmem,
guint ix)
{
Magazine *mag = &tmem->magazine2[ix];
magazine_cache_push_magazine (ix, mag->chunks, mag->count);
mag->chunks = NULL;
mag->count = 0;
}
static inline void
thread_memory_swap_magazines (ThreadMemory *tmem,
guint ix)
{
Magazine xmag = tmem->magazine1[ix];
tmem->magazine1[ix] = tmem->magazine2[ix];
tmem->magazine2[ix] = xmag;
}
static inline gboolean
thread_memory_magazine1_is_empty (ThreadMemory *tmem,
guint ix)
{
return tmem->magazine1[ix].chunks == NULL;
}
static inline gboolean
thread_memory_magazine2_is_full (ThreadMemory *tmem,
guint ix)
{
return tmem->magazine2[ix].count >= allocator_get_magazine_threshold (allocator, ix);
}
static inline gpointer
thread_memory_magazine1_alloc (ThreadMemory *tmem,
guint ix)
{
Magazine *mag = &tmem->magazine1[ix];
ChunkLink *chunk = magazine_chain_pop_head (&mag->chunks);
if (G_LIKELY (mag->count > 0))
mag->count--;
return chunk;
}
static inline void
thread_memory_magazine2_free (ThreadMemory *tmem,
guint ix,
gpointer mem)
{
Magazine *mag = &tmem->magazine2[ix];
ChunkLink *chunk = mem;
chunk->data = NULL;
chunk->next = mag->chunks;
mag->chunks = chunk;
mag->count++;
}
/* --- API functions --- */
gpointer
g_slice_alloc (gsize mem_size)
{
gsize chunk_size;
gpointer mem;
guint acat;
chunk_size = P2ALIGN (mem_size);
acat = allocator_categorize (chunk_size);
if (G_LIKELY (acat == 1)) /* allocate through magazine layer */
{
ThreadMemory *tmem = thread_memory_from_self();
guint ix = SLAB_INDEX (allocator, chunk_size);
if (G_UNLIKELY (thread_memory_magazine1_is_empty (tmem, ix)))
{
thread_memory_swap_magazines (tmem, ix);
if (G_UNLIKELY (thread_memory_magazine1_is_empty (tmem, ix)))
thread_memory_magazine1_reload (tmem, ix);
}
mem = thread_memory_magazine1_alloc (tmem, ix);
}
else if (acat == 2) /* allocate through slab allocator */
{
g_mutex_lock (allocator->slab_mutex);
mem = slab_allocator_alloc_chunk (chunk_size);
g_mutex_unlock (allocator->slab_mutex);
}
else /* delegate to system malloc */
mem = g_malloc (mem_size);
return mem;
}
gpointer
g_slice_alloc0 (guint mem_size)
{
gpointer mem = g_slice_alloc (mem_size);
if (mem)
memset (mem, 0, mem_size);
return mem;
}
void
g_slice_free1 (guint mem_size,
gpointer mem_block)
{
guint chunk_size = P2ALIGN (mem_size);
guint acat = allocator_categorize (chunk_size);
if (G_UNLIKELY (!mem_block))
/* pass */;
else if (G_LIKELY (acat == 1)) /* allocate through magazine layer */
{
ThreadMemory *tmem = thread_memory_from_self();
guint ix = SLAB_INDEX (allocator, chunk_size);
if (G_UNLIKELY (thread_memory_magazine2_is_full (tmem, ix)))
{
thread_memory_swap_magazines (tmem, ix);
if (G_UNLIKELY (thread_memory_magazine2_is_full (tmem, ix)))
thread_memory_magazine2_unload (tmem, ix);
}
thread_memory_magazine2_free (tmem, ix, mem_block);
}
else if (acat == 2) /* allocate through slab allocator */
{
g_mutex_lock (allocator->slab_mutex);
slab_allocator_free_chunk (chunk_size, mem_block);
g_mutex_unlock (allocator->slab_mutex);
}
else /* delegate to system malloc */
g_free (mem_block);
}
void
g_slice_free_chain (guint mem_size,
gpointer mem_chain,
guint next_offset)
{
GSList *slice = mem_chain;
g_return_if_fail (next_offset == G_STRUCT_OFFSET (GSList, next));
g_return_if_fail (mem_size >= sizeof (GSList));
while (slice)
{
GSList *current = slice;
slice = slice->next;
g_slice_free1 (mem_size, current);
}
/* while the thread magazines and the magazine cache are implemented so that
* they can easily be extended to allow for free lists containing more free
* lists for the first level nodes, which would allow O(1) freeing in this
* function, the benefit of such an extension is questionable, because:
* - the magazine size counts will become mere lower bounds which confuses
* the code adapting to lock contention;
* - freeing a single node to the thread magazines is very fast, so this
* O(list_length) operation is multiplied by a fairly small factor;
* - memory usage histograms on larger applications seem to indicate that
* the amount of released multi node lists is negligible in comparison
* to single node releases.
*/
}
/* --- single page allocator --- */
static void
allocator_slab_stack_push (Allocator *allocator,
guint ix,
SlabInfo *sinfo)
{
/* insert slab at slab ring head */
if (!allocator->slab_stack[ix])
{
sinfo->next = sinfo;
sinfo->prev = sinfo;
}
else
{
SlabInfo *next = allocator->slab_stack[ix], *prev = next->prev;
next->prev = sinfo;
prev->next = sinfo;
sinfo->next = next;
sinfo->prev = prev;
}
allocator->slab_stack[ix] = sinfo;
}
static void
allocator_add_slab (Allocator *allocator,
guint ix,
guint chunk_size)
{
SlabInfo *sinfo;
gsize padding, n_chunks, color = 0;
gsize page_size = SLAB_PAGE_SIZE (allocator, chunk_size);
/* allocate 1 page for the chunks and the slab */
gpointer aligned_memory = allocator_memalign (page_size, page_size - NATIVE_MALLOC_PADDING);
guint8 *mem = aligned_memory;
if (!mem)
g_error ("%s: failed to allocate %lu bytes: %s", "GSlicedMemory", (gulong) (page_size - NATIVE_MALLOC_PADDING), g_strerror (errno));
/* mask page adress */
gsize addr = ((gsize) mem / page_size) * page_size;
/* assert alignment */
g_assert (aligned_memory == (gpointer) addr);
/* basic slab info setup */
sinfo = (SlabInfo*) (mem + page_size - SLAB_INFO_SIZE);
sinfo->n_allocated = 0;
sinfo->chunks = NULL;
/* figure cache colorization */
n_chunks = ((guint8*) sinfo - mem) / chunk_size;
padding = ((guint8*) sinfo - mem) - n_chunks * chunk_size;
if (padding)
{
color = (allocator->color_accu * P2ALIGNMENT) % padding;
allocator->color_accu += 1; /* alternatively: + 0x7fffffff */
}
/* add chunks to free list */
ChunkLink *chunk = (ChunkLink*) (mem + color);
guint i;
sinfo->chunks = chunk;
for (i = 0; i < n_chunks - 1; i++)
{
chunk->next = (ChunkLink*) ((guint8*) chunk + chunk_size);
chunk = chunk->next;
}
chunk->next = NULL; /* last chunk */
/* add slab to slab ring */
allocator_slab_stack_push (allocator, ix, sinfo);
}
static gpointer
slab_allocator_alloc_chunk (guint chunk_size)
{
guint ix = SLAB_INDEX (allocator, chunk_size);
/* ensure non-empty slab */
if (!allocator->slab_stack[ix] || !allocator->slab_stack[ix]->chunks)
allocator_add_slab (allocator, ix, chunk_size);
/* allocate chunk */
ChunkLink *chunk = allocator->slab_stack[ix]->chunks;
allocator->slab_stack[ix]->chunks = chunk->next;
allocator->slab_stack[ix]->n_allocated++;
/* rotate empty slabs */
if (!allocator->slab_stack[ix]->chunks)
allocator->slab_stack[ix] = allocator->slab_stack[ix]->next;
return chunk;
}
static void
slab_allocator_free_chunk (guint chunk_size,
gpointer mem)
{
guint ix = SLAB_INDEX (allocator, chunk_size);
gsize page_size = SLAB_PAGE_SIZE (allocator, chunk_size);
gsize addr = ((gsize) mem / page_size) * page_size;
/* mask page adress */
guint8 *page = (guint8*) addr;
SlabInfo *sinfo = (SlabInfo*) (page + page_size - SLAB_INFO_SIZE);
/* assert valid chunk count */
g_assert (sinfo->n_allocated > 0);
/* add chunk to free list */
gboolean was_empty = sinfo->chunks == NULL;
ChunkLink *chunk = (ChunkLink*) mem;
chunk->next = sinfo->chunks;
sinfo->chunks = chunk;
sinfo->n_allocated--;
/* keep slab ring partially sorted, empty slabs at end */
if (was_empty)
{
/* unlink slab */
SlabInfo *next = sinfo->next, *prev = sinfo->prev;
next->prev = prev;
prev->next = next;
if (allocator->slab_stack[ix] == sinfo)
allocator->slab_stack[ix] = next == sinfo ? NULL : next;
/* insert slab at head */
allocator_slab_stack_push (allocator, ix, sinfo);
}
/* eagerly free complete unused slabs */
if (!sinfo->n_allocated)
{
/* unlink slab */
SlabInfo *next = sinfo->next, *prev = sinfo->prev;
next->prev = prev;
prev->next = next;
if (allocator->slab_stack[ix] == sinfo)
allocator->slab_stack[ix] = next == sinfo ? NULL : next;
/* free slab */
allocator_memfree (page_size, page);
}
}
/* --- memalign implementation --- */
#include <malloc.h> /* memalign() */
/* from config.h:
* define HAVE_POSIX_MEMALIGN 1 // if free(posix_memalign(3)) works, <stdlib.h>
* define HAVE_MEMALIGN 1 // if free(memalign(3)) works, <malloc.h>
* define HAVE_VALLOC 1 // if free(valloc(3)) works, <stdlib.h> or <malloc.h>
* if none is provided, we implement malloc(3)-based alloc-only page alignment
*/
#if !(HAVE_POSIX_MEMALIGN || HAVE_MEMALIGN || HAVE_VALLOC)
static GTrashStack *compat_valloc_trash = NULL;
#endif
static gpointer
allocator_memalign (gsize alignment,
gsize memsize)
{
gpointer aligned_memory = NULL;
gint err = ENOMEM;
#if HAVE_POSIX_MEMALIGN
err = posix_memalign (&aligned_memory, alignment, memsize);
#elif HAVE_MEMALIGN
errno = 0;
aligned_memory = memalign (alignment, memsize);
err = errno;
#elif HAVE_VALLOC
errno = 0;
aligned_memory = valloc (memsize);
err = errno;
#else
/* simplistic non-freeing page allocator */
g_assert (alignment == sys_page_size);
g_assert (memsize <= sys_page_size);
if (!compat_valloc_trash)
{
const guint n_pages = 16;
guint8 *mem = malloc (n_pages * sys_page_size);
err = errno;
if (mem)
{
gint i = n_pages;
guint8 *amem = (guint8*) ALIGN ((gsize) mem, sys_page_size);
if (amem != mem)
i--; /* mem wasn't page aligned */
while (--i >= 0)
g_trash_stack_push (&compat_valloc_trash, amem + i * sys_page_size);
}
}
aligned_memory = g_trash_stack_pop (&compat_valloc_trash);
#endif
if (!aligned_memory)
errno = err;
return aligned_memory;
}
static void
allocator_memfree (gsize memsize,
gpointer mem)
{
#if HAVE_POSIX_MEMALIGN || HAVE_MEMALIGN || HAVE_VALLOC
free (mem);
#else
g_assert (memsize <= sys_page_size);
g_trash_stack_push (&compat_valloc_trash, mem);
#endif
}
#define __G_SLICE_C__
#include "galiasdef.c"

70
glib/gslice.h Normal file
View File

@ -0,0 +1,70 @@
/* GLIB sliced memory - fast threaded memory chunk allocator
* Copyright (C) 2005 Tim Janik
*
* This library 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 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
* 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.
*/
#ifndef __G_SLICE_H__
#define __G_SLICE_H__
#ifndef __G_MEM_H__
#error Include <glib.h> instead of <gslice.h>
#endif
#include <glib/gtypes.h>
G_BEGIN_DECLS
/* slices - fast allocation/release of small memory blocks
*/
gpointer g_slice_alloc (gsize block_size) G_GNUC_MALLOC;
gpointer g_slice_alloc0 (gsize block_size) G_GNUC_MALLOC;
void g_slice_free1 (gsize block_size,
gpointer mem_block);
void g_slice_free_chain (gsize block_size,
gpointer mem_chain,
gsize next_offset);
#define g_slice_new(type) ((type*) g_slice_alloc (sizeof (type)))
#define g_slice_new0(type) ((type*) g_slice_alloc0 (sizeof (type)))
/* g_slice_free(type,mem) g_slice_free1 (sizeof (type), mem) */
#if __GNUC__ >= 2
/* for GCC, define a type-safe variant of g_slice_free() */
#define g_slice_free(type, mem) ({ \
static inline void g_slice_free (gsize, type*); \
while (0) g_slice_free (sizeof (type), mem); \
g_slice_free1 (sizeof (type), mem); \
})
#else
#define g_slice_free(type, mem) g_slice_free1 (sizeof (type) + (gsize) (type*) 0, mem)
/* we go through the extra (gsize)(type*)0 hoop to ensure a known type argument */
#endif
/* --- internal debugging API --- */
typedef enum {
G_SLICE_CONFIG_ALWAYS_MALLOC = 1,
G_SLICE_CONFIG_BYPASS_MAGAZINES,
G_SLICE_CONFIG_ALWAYS_FREE,
G_SLICE_CONFIG_WORKING_SET_MSECS,
G_SLICE_CONFIG_CHUNK_SIZES,
G_SLICE_CONFIG_CONTENTION_COUNTER,
} GSliceConfig;
void g_slice_set_config (GSliceConfig ckey, gint64 value);
gint64 g_slice_get_config (GSliceConfig ckey);
gint64* g_slice_get_config_state (GSliceConfig ckey, gint64 address, guint *n_values);
G_END_DECLS
#endif /* __G_SLICE_H__ */

52
glib/gthread.c
View File

@ -76,7 +76,6 @@ struct _GRealThread
{
GThread thread;
gpointer private_data;
gpointer mem_private;
GRealThread *next;
gpointer retval;
GSystemThread system_thread;
@ -145,29 +144,34 @@ g_thread_init_glib (void)
*/
GRealThread* main_thread = (GRealThread*) g_thread_self ();
/* mutex and cond creation works without g_threads_got_initialized */
g_once_mutex = g_mutex_new ();
g_once_cond = g_cond_new ();
/* we may only create mutex and cond in here */
_g_mem_thread_init_noprivate_nomessage ();
/* setup the basic threading system */
g_threads_got_initialized = TRUE;
g_thread_specific_private = g_private_new (g_thread_cleanup);
g_private_set (g_thread_specific_private, main_thread);
G_THREAD_UF (thread_self, (&main_thread->system_thread));
/* complete memory system initialization, g_private_*() works now */
_g_slice_thread_init_nomessage ();
/* accomplish log system initialization to enable messaging */
_g_messages_thread_init_nomessage ();
/* we may run full-fledged initializers from here */
_g_convert_thread_init ();
_g_rand_thread_init ();
_g_main_thread_init ();
_g_mem_thread_init ();
_g_messages_thread_init ();
_g_atomic_thread_init ();
_g_utils_thread_init ();
#ifdef G_OS_WIN32
_g_win32_thread_init ();
#endif
g_threads_got_initialized = TRUE;
g_thread_specific_private = g_private_new (g_thread_cleanup);
g_private_set (g_thread_specific_private, main_thread);
G_THREAD_UF (thread_self, (&main_thread->system_thread));
_g_mem_thread_private_init ();
_g_messages_thread_private_init ();
}
#endif /* G_THREADS_ENABLED */
@ -868,28 +872,6 @@ g_static_rw_lock_free (GStaticRWLock* lock)
g_static_mutex_free (&lock->mutex);
}
/*
* Memory allocation can't use the regular GPrivate
* API, since that relies on GArray, which uses
* chunked memory.
*/
gpointer
_g_thread_mem_private_get (GThread *thread)
{
GRealThread *real_thread = (GRealThread*) thread;
return real_thread->mem_private;
}
void
_g_thread_mem_private_set (GThread *thread,
gpointer data)
{
GRealThread *real_thread = (GRealThread*) thread;
real_thread->mem_private = data;
}
/**
* g_thread_foreach
* @thread_func: function to call for all GThread structures

4
glib/gthread.h
View File

@ -370,10 +370,6 @@ extern void glib_dummy_decl (void);
# define G_TRYLOCK(name) (TRUE)
#endif /* !G_THREADS_ENABLED */
/* --- internal API --- */
gpointer _g_thread_mem_private_get (GThread *thread);
void _g_thread_mem_private_set (GThread *thread,
gpointer data);
G_END_DECLS

16
glib/gthreadinit.h
View File

@ -26,9 +26,13 @@ G_BEGIN_DECLS
/* Is called from gthread/gthread-impl.c */
void g_thread_init_glib (void);
/* Are called from glib/gthread.c. May not contain g_private_new calls */
void _g_mem_thread_init (void) G_GNUC_INTERNAL;
void _g_messages_thread_init (void) G_GNUC_INTERNAL;
/* base initializers, may only use g_mutex_new(), g_cond_new() */
void _g_mem_thread_init_noprivate_nomessage (void) G_GNUC_INTERNAL;
/* initializers that may also use g_private_new() */
void _g_slice_thread_init_nomessage (void) G_GNUC_INTERNAL;
void _g_messages_thread_init_nomessage (void) G_GNUC_INTERNAL;
/* full fledged initializersa */
void _g_convert_thread_init (void) G_GNUC_INTERNAL;
void _g_rand_thread_init (void) G_GNUC_INTERNAL;
void _g_main_thread_init (void) G_GNUC_INTERNAL;
@ -38,8 +42,10 @@ void _g_utils_thread_init (void) G_GNUC_INTERNAL;
void _g_win32_thread_init (void) G_GNUC_INTERNAL;
#endif
/* Are called from glib/gthread.c. Must only contain g_private_new calls */
void _g_mem_thread_private_init (void) G_GNUC_INTERNAL;
/* initialization functions called from glib/gthread.c.
* may contain g_mutex_new().
* may contain g_private_new() calls.
*/
void _g_messages_thread_private_init (void) G_GNUC_INTERNAL;
G_END_DECLS

2
tests/Makefile.am
View File

@ -91,6 +91,7 @@ test_programs = \
relation-test \
shell-test \
slist-test \
slice-test \
spawn-test \
$(spawn_test_win32_gui) \
strfunc-test \
@ -150,6 +151,7 @@ rand_test_LDADD = $(progs_ldadd)
relation_test_LDADD = $(progs_ldadd)
shell_test_LDADD = $(progs_ldadd)
slist_test_LDADD = $(progs_ldadd)
slice_test_LDADD = $(thread_ldadd)
spawn_test_LDADD = $(progs_ldadd)
strfunc_test_LDADD = $(progs_ldadd)
string_test_LDADD = $(progs_ldadd)

168
tests/slice-test.c Normal file
View File

@ -0,0 +1,168 @@
/* GLIB sliced memory - fast threaded memory chunk allocator
* Copyright (C) 2005 Tim Janik
*
* This library 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 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
* 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.
*/
#include <glib.h>
#include <stdio.h>
#include <string.h>
#include <sys/time.h> // gettimeofday
#define quick_rand32() (rand_accu = 1664525 * rand_accu + 1013904223, rand_accu)
static guint prime_size = 1021; // 769; // 509
static gpointer
test_sliced_mem_thread (gpointer data)
{
guint32 rand_accu = 2147483563;
/* initialize random numbers */
if (data)
rand_accu = *(guint32*) data;
else
{
struct timeval rand_tv;
gettimeofday (&rand_tv, NULL);
rand_accu = rand_tv.tv_usec + (rand_tv.tv_sec << 16);
}
guint i, m = 10000; /* number of blocks */
guint j, n = 10000; /* number of alloc+free repetitions */
guint8 **ps = g_new (guint8*, m);
guint *ss = g_new (guint, m);
/* create m random sizes */
for (i = 0; i < m; i++)
ss[i] = quick_rand32() % prime_size;
/* allocate m blocks */
for (i = 0; i < m; i++)
ps[i] = g_slice_alloc (ss[i]);
for (j = 0; j < n; j++)
{
/* free m/2 blocks */
for (i = 0; i < m; i += 2)
g_slice_free1 (ss[i], ps[i]);
/* allocate m/2 blocks with new sizes */
for (i = 0; i < m; i += 2)
{
ss[i] = quick_rand32() % prime_size;
ps[i] = g_slice_alloc (ss[i]);
}
}
/* free m blocks */
for (i = 0; i < m; i++)
g_slice_free1 (ss[i], ps[i]);
/* alloc and free many equally sized chunks in a row */
for (i = 0; i < n; i++)
{
guint sz = quick_rand32() % prime_size;
guint k = m / 100;
for (j = 0; j < k; j++)
ps[j] = g_slice_alloc (sz);
for (j = 0; j < k; j++)
g_slice_free1 (sz, ps[j]);
}
return NULL;
}
static void
usage (void)
{
g_print ("Usage: gslicedmemory [n_threads] [G|S|M][f][c] [maxblocksize] [seed]\n");
}
int
main (int argc,
char *argv[])
{
guint seed32, *seedp = NULL;
gboolean ccounters = FALSE;
guint n_threads = 1;
const gchar *mode = "slab allocator + magazine cache", *emode = " ";
if (argc > 1)
n_threads = g_ascii_strtoull (argv[1], NULL, 10);
if (argc > 2)
{
guint i, l = strlen (argv[2]);
for (i = 0; i < l; i++)
switch (argv[2][i])
{
case 'G': /* GLib mode */
g_slice_set_config (G_SLICE_CONFIG_ALWAYS_MALLOC, FALSE);
g_slice_set_config (G_SLICE_CONFIG_BYPASS_MAGAZINES, FALSE);
mode = "slab allocator + magazine cache";
break;
case 'S': /* slab mode */
g_slice_set_config (G_SLICE_CONFIG_ALWAYS_MALLOC, FALSE);
g_slice_set_config (G_SLICE_CONFIG_BYPASS_MAGAZINES, TRUE);
mode = "slab allocator";
break;
case 'M': /* malloc mode */
g_slice_set_config (G_SLICE_CONFIG_ALWAYS_MALLOC, TRUE);
mode = "system malloc";
break;
case 'f': /* eager freeing */
g_slice_set_config (G_SLICE_CONFIG_ALWAYS_FREE, TRUE);
emode = " with eager freeing";
break;
case 'c': /* print contention counters */
ccounters = TRUE;
break;
default:
usage();
return 1;
}
}
if (argc > 3)
prime_size = g_ascii_strtoull (argv[3], NULL, 10);
if (argc > 4)
{
seed32 = g_ascii_strtoull (argv[4], NULL, 10);
seedp = &seed32;
}
g_thread_init (NULL);
if (argc <= 1)
usage();
gchar strseed[64] = "<random>";
if (seedp)
g_snprintf (strseed, 64, "%u", *seedp);
g_print ("Starting %d threads allocating random blocks <= %u bytes with seed=%s using %s%s\n", n_threads, prime_size, strseed, mode, emode);
GThread *threads[n_threads];
guint i;
for (i = 0; i < n_threads; i++)
threads[i] = g_thread_create_full (test_sliced_mem_thread, seedp, 0, TRUE, FALSE, 0, NULL);
for (i = 0; i < n_threads; i++)
g_thread_join (threads[i]);
if (ccounters)
{
guint n, n_chunks = g_slice_get_config (G_SLICE_CONFIG_CHUNK_SIZES);
g_print (" ChunkSize | MagazineSize | Contention\n");
for (i = 0; i < n_chunks; i++)
{
gint64 *vals = g_slice_get_config_state (G_SLICE_CONFIG_CONTENTION_COUNTER, i, &n);
g_print (" %9llu | %9llu | %9llu\n", vals[0], vals[2], vals[1]);
g_free (vals);
}
}
else
g_print ("Done.\n");
return 0;
}