+Tue Aug 18 04:40:17 1998 Tim Janik <timj@gtk.org>
+
+ * glib.h:
+ * gmessages.c: new function g_log_set_always_fatal() to set an
+ additional fatal_mask for log levels that are considered to be fatal
+ globally (required by gtk). since this mask is not domain-associated,
+ it is restricted to the log levels, introduced by glib itself.
+
+ * gmem.c:
+ * grel.c:
+ * gtree.c (g_tree_node_check):
+ don't use g_print() calls for informational/debugging output,
+ but log all this stuff through g_log() with G_LOG_LEVEL_INFO.
+ libraries shouldn't use printf(), g_print() or g_printerr() at all.
+
Tue Aug 18 02:46:44 1998 Tim Janik <timj@gtk.org>
+
* glib.h (__STRICT_ANSI__): if __STRICT_ANSI__ is defined, make
`inline' a noop, since strict ANSI rules don't permit `inline'.
+Tue Aug 18 04:40:17 1998 Tim Janik <timj@gtk.org>
+
+ * glib.h:
+ * gmessages.c: new function g_log_set_always_fatal() to set an
+ additional fatal_mask for log levels that are considered to be fatal
+ globally (required by gtk). since this mask is not domain-associated,
+ it is restricted to the log levels, introduced by glib itself.
+
+ * gmem.c:
+ * grel.c:
+ * gtree.c (g_tree_node_check):
+ don't use g_print() calls for informational/debugging output,
+ but log all this stuff through g_log() with G_LOG_LEVEL_INFO.
+ libraries shouldn't use printf(), g_print() or g_printerr() at all.
+
Tue Aug 18 02:46:44 1998 Tim Janik <timj@gtk.org>
+
* glib.h (__STRICT_ANSI__): if __STRICT_ANSI__ is defined, make
`inline' a noop, since strict ANSI rules don't permit `inline'.
+Tue Aug 18 04:40:17 1998 Tim Janik <timj@gtk.org>
+
+ * glib.h:
+ * gmessages.c: new function g_log_set_always_fatal() to set an
+ additional fatal_mask for log levels that are considered to be fatal
+ globally (required by gtk). since this mask is not domain-associated,
+ it is restricted to the log levels, introduced by glib itself.
+
+ * gmem.c:
+ * grel.c:
+ * gtree.c (g_tree_node_check):
+ don't use g_print() calls for informational/debugging output,
+ but log all this stuff through g_log() with G_LOG_LEVEL_INFO.
+ libraries shouldn't use printf(), g_print() or g_printerr() at all.
+
Tue Aug 18 02:46:44 1998 Tim Janik <timj@gtk.org>
+
* glib.h (__STRICT_ANSI__): if __STRICT_ANSI__ is defined, make
`inline' a noop, since strict ANSI rules don't permit `inline'.
+Tue Aug 18 04:40:17 1998 Tim Janik <timj@gtk.org>
+
+ * glib.h:
+ * gmessages.c: new function g_log_set_always_fatal() to set an
+ additional fatal_mask for log levels that are considered to be fatal
+ globally (required by gtk). since this mask is not domain-associated,
+ it is restricted to the log levels, introduced by glib itself.
+
+ * gmem.c:
+ * grel.c:
+ * gtree.c (g_tree_node_check):
+ don't use g_print() calls for informational/debugging output,
+ but log all this stuff through g_log() with G_LOG_LEVEL_INFO.
+ libraries shouldn't use printf(), g_print() or g_printerr() at all.
+
Tue Aug 18 02:46:44 1998 Tim Janik <timj@gtk.org>
+
* glib.h (__STRICT_ANSI__): if __STRICT_ANSI__ is defined, make
`inline' a noop, since strict ANSI rules don't permit `inline'.
+Tue Aug 18 04:40:17 1998 Tim Janik <timj@gtk.org>
+
+ * glib.h:
+ * gmessages.c: new function g_log_set_always_fatal() to set an
+ additional fatal_mask for log levels that are considered to be fatal
+ globally (required by gtk). since this mask is not domain-associated,
+ it is restricted to the log levels, introduced by glib itself.
+
+ * gmem.c:
+ * grel.c:
+ * gtree.c (g_tree_node_check):
+ don't use g_print() calls for informational/debugging output,
+ but log all this stuff through g_log() with G_LOG_LEVEL_INFO.
+ libraries shouldn't use printf(), g_print() or g_printerr() at all.
+
Tue Aug 18 02:46:44 1998 Tim Janik <timj@gtk.org>
+
* glib.h (__STRICT_ANSI__): if __STRICT_ANSI__ is defined, make
`inline' a noop, since strict ANSI rules don't permit `inline'.
+Tue Aug 18 04:40:17 1998 Tim Janik <timj@gtk.org>
+
+ * glib.h:
+ * gmessages.c: new function g_log_set_always_fatal() to set an
+ additional fatal_mask for log levels that are considered to be fatal
+ globally (required by gtk). since this mask is not domain-associated,
+ it is restricted to the log levels, introduced by glib itself.
+
+ * gmem.c:
+ * grel.c:
+ * gtree.c (g_tree_node_check):
+ don't use g_print() calls for informational/debugging output,
+ but log all this stuff through g_log() with G_LOG_LEVEL_INFO.
+ libraries shouldn't use printf(), g_print() or g_printerr() at all.
+
Tue Aug 18 02:46:44 1998 Tim Janik <timj@gtk.org>
+
* glib.h (__STRICT_ANSI__): if __STRICT_ANSI__ is defined, make
`inline' a noop, since strict ANSI rules don't permit `inline'.
+Tue Aug 18 04:40:17 1998 Tim Janik <timj@gtk.org>
+
+ * glib.h:
+ * gmessages.c: new function g_log_set_always_fatal() to set an
+ additional fatal_mask for log levels that are considered to be fatal
+ globally (required by gtk). since this mask is not domain-associated,
+ it is restricted to the log levels, introduced by glib itself.
+
+ * gmem.c:
+ * grel.c:
+ * gtree.c (g_tree_node_check):
+ don't use g_print() calls for informational/debugging output,
+ but log all this stuff through g_log() with G_LOG_LEVEL_INFO.
+ libraries shouldn't use printf(), g_print() or g_printerr() at all.
+
Tue Aug 18 02:46:44 1998 Tim Janik <timj@gtk.org>
+
* glib.h (__STRICT_ANSI__): if __STRICT_ANSI__ is defined, make
`inline' a noop, since strict ANSI rules don't permit `inline'.
+Tue Aug 18 04:40:17 1998 Tim Janik <timj@gtk.org>
+
+ * glib.h:
+ * gmessages.c: new function g_log_set_always_fatal() to set an
+ additional fatal_mask for log levels that are considered to be fatal
+ globally (required by gtk). since this mask is not domain-associated,
+ it is restricted to the log levels, introduced by glib itself.
+
+ * gmem.c:
+ * grel.c:
+ * gtree.c (g_tree_node_check):
+ don't use g_print() calls for informational/debugging output,
+ but log all this stuff through g_log() with G_LOG_LEVEL_INFO.
+ libraries shouldn't use printf(), g_print() or g_printerr() at all.
+
Tue Aug 18 02:46:44 1998 Tim Janik <timj@gtk.org>
+
* glib.h (__STRICT_ANSI__): if __STRICT_ANSI__ is defined, make
`inline' a noop, since strict ANSI rules don't permit `inline'.
va_list *args2);
GLogLevelFlags g_log_set_fatal_mask (const gchar *log_domain,
GLogLevelFlags fatal_mask);
+GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask);
#ifndef G_LOG_DOMAIN
#define G_LOG_DOMAIN (NULL)
#endif /* G_LOG_DOMAIN */
va_list *args2);
GLogLevelFlags g_log_set_fatal_mask (const gchar *log_domain,
GLogLevelFlags fatal_mask);
+GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask);
#ifndef G_LOG_DOMAIN
#define G_LOG_DOMAIN (NULL)
#endif /* G_LOG_DOMAIN */
g_malloc (gulong size)
{
gpointer p;
-
-
+
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
gulong *t;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
-
+
+
if (size == 0)
return NULL;
-
-
+
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
size += SIZEOF_LONG;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
+
#ifdef ENABLE_MEM_CHECK
size += SIZEOF_LONG;
#endif /* ENABLE_MEM_CHECK */
-
-
+
+
p = (gpointer) malloc (size);
if (!p)
g_error ("could not allocate %ld bytes", size);
-
-
+
+
#ifdef ENABLE_MEM_CHECK
size -= SIZEOF_LONG;
-
+
t = p;
p = ((guchar*) p + SIZEOF_LONG);
*t = 0;
#endif /* ENABLE_MEM_CHECK */
-
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
size -= SIZEOF_LONG;
-
+
t = p;
p = ((guchar*) p + SIZEOF_LONG);
*t = size;
-
+
#ifdef ENABLE_MEM_PROFILE
if (size <= 4095)
allocations[size-1] += 1;
allocated_mem += size;
#endif /* ENABLE_MEM_PROFILE */
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
-
+
+
return p;
}
g_malloc0 (gulong size)
{
gpointer p;
-
-
+
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
gulong *t;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
-
+
+
if (size == 0)
return NULL;
-
-
+
+
#ifdef ENABLE_MEM_PROFILE
size += SIZEOF_LONG;
#endif /* ENABLE_MEM_PROFILE */
-
+
#ifdef ENABLE_MEM_CHECK
size += SIZEOF_LONG;
#endif /* ENABLE_MEM_CHECK */
-
-
+
+
p = (gpointer) calloc (size, 1);
if (!p)
g_error ("could not allocate %ld bytes", size);
-
-
+
+
#ifdef ENABLE_MEM_CHECK
size -= SIZEOF_LONG;
-
+
t = p;
p = ((guchar*) p + SIZEOF_LONG);
*t = 0;
#endif /* ENABLE_MEM_CHECK */
-
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
size -= SIZEOF_LONG;
-
+
t = p;
p = ((guchar*) p + SIZEOF_LONG);
*t = size;
-
+
#ifdef ENABLE_MEM_PROFILE
if (size <= 4095)
allocations[size-1] += 1;
allocated_mem += size;
#endif /* ENABLE_MEM_PROFILE */
#endif /* ENABLE_MEM_PROFILE */
-
-
+
+
return p;
}
gulong size)
{
gpointer p;
-
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
gulong *t;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
-
+
+
if (size == 0)
return NULL;
-
-
+
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
size += SIZEOF_LONG;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
+
#ifdef ENABLE_MEM_CHECK
size += SIZEOF_LONG;
#endif /* ENABLE_MEM_CHECK */
-
-
+
+
if (!mem)
p = (gpointer) malloc (size);
else
#endif /* ENABLE_MEM_PROFILE */
mem = t;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
+
#ifdef ENABLE_MEM_CHECK
t = (gulong*) ((guchar*) mem - SIZEOF_LONG);
if (*t >= 1)
g_warning ("trying to realloc freed memory\n");
mem = t;
#endif /* ENABLE_MEM_CHECK */
-
+
p = (gpointer) realloc (mem, size);
}
-
+
if (!p)
g_error ("could not reallocate %ld bytes", size);
-
-
+
+
#ifdef ENABLE_MEM_CHECK
size -= SIZEOF_LONG;
-
+
t = p;
p = ((guchar*) p + SIZEOF_LONG);
*t = 0;
#endif /* ENABLE_MEM_CHECK */
-
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
size -= SIZEOF_LONG;
-
+
t = p;
p = ((guchar*) p + SIZEOF_LONG);
*t = size;
-
+
#ifdef ENABLE_MEM_PROFILE
if (size <= 4095)
allocations[size-1] += 1;
allocated_mem += size;
#endif /* ENABLE_MEM_PROFILE */
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
-
+
+
return p;
}
gulong *t;
gulong size;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
t = (gulong*) ((guchar*) mem - SIZEOF_LONG);
size = *t;
#endif /* ENABLE_MEM_PROFILE */
mem = t;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
+
#ifdef ENABLE_MEM_CHECK
t = (gulong*) ((guchar*) mem - SIZEOF_LONG);
if (*t >= 1)
g_warning ("freeing previously freed memory\n");
*t += 1;
mem = t;
-
+
memset ((guchar*) mem + 8, 0, size);
#else /* ENABLE_MEM_CHECK */
free (mem);
{
#ifdef ENABLE_MEM_PROFILE
gint i;
-
+
for (i = 0; i < 4095; i++)
if (allocations[i] > 0)
- g_print ("%lu allocations of %d bytes\n", allocations[i], i + 1);
-
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO,
+ "%lu allocations of %d bytes\n", allocations[i], i + 1);
+
if (allocations[4095] > 0)
- g_print ("%lu allocations of greater than 4095 bytes\n", allocations[4095]);
- g_print ("%lu bytes allocated\n", allocated_mem);
- g_print ("%lu bytes freed\n", freed_mem);
- g_print ("%lu bytes in use\n", allocated_mem - freed_mem);
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO,
+ "%lu allocations of greater than 4095 bytes\n", allocations[4095]);
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%lu bytes allocated\n", allocated_mem);
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%lu bytes freed\n", freed_mem);
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%lu bytes in use\n", allocated_mem - freed_mem);
#endif /* ENABLE_MEM_PROFILE */
}
{
#ifdef ENABLE_MEM_CHECK
gulong *t;
-
+
t = (gulong*) ((guchar*) mem - SIZEOF_LONG - SIZEOF_LONG);
-
+
if (*t >= 1)
g_warning ("mem: 0x%08x has been freed: %lu\n", (gulong) mem, *t);
#endif /* ENABLE_MEM_CHECK */
{
GRealMemChunk *mem_chunk;
gulong rarea_size;
-
+
mem_chunk = g_new (struct _GRealMemChunk, 1);
mem_chunk->name = name;
mem_chunk->type = type;
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 % MEM_ALIGN)
mem_chunk->atom_size += MEM_ALIGN - (mem_chunk->atom_size % MEM_ALIGN);
-
+
mem_chunk->area_size = area_size;
if (mem_chunk->area_size > MAX_MEM_AREA)
mem_chunk->area_size = MAX_MEM_AREA;
while (mem_chunk->area_size < mem_chunk->atom_size)
mem_chunk->area_size *= 2;
-
+
rarea_size = mem_chunk->area_size + sizeof (GMemArea) - MEM_AREA_SIZE;
rarea_size = g_mem_chunk_compute_size (rarea_size);
mem_chunk->area_size = rarea_size - (sizeof (GMemArea) - MEM_AREA_SIZE);
-
+
/*
- mem_chunk->area_size -= (sizeof (GMemArea) - MEM_AREA_SIZE);
- if (mem_chunk->area_size < mem_chunk->atom_size)
+ mem_chunk->area_size -= (sizeof (GMemArea) - MEM_AREA_SIZE);
+ if (mem_chunk->area_size < mem_chunk->atom_size)
{
- mem_chunk->area_size = (mem_chunk->area_size + sizeof (GMemArea) - MEM_AREA_SIZE) * 2;
- mem_chunk->area_size -= (sizeof (GMemArea) - MEM_AREA_SIZE);
+ mem_chunk->area_size = (mem_chunk->area_size + sizeof (GMemArea) - MEM_AREA_SIZE) * 2;
+ mem_chunk->area_size -= (sizeof (GMemArea) - MEM_AREA_SIZE);
}
-
- if (mem_chunk->area_size % mem_chunk->atom_size)
+
+ if (mem_chunk->area_size % mem_chunk->atom_size)
mem_chunk->area_size += mem_chunk->atom_size - (mem_chunk->area_size % mem_chunk->atom_size);
- */
-
+ */
+
mem_chunk->next = mem_chunks;
mem_chunk->prev = NULL;
if (mem_chunks)
mem_chunks->prev = mem_chunk;
mem_chunks = mem_chunk;
-
+
return ((GMemChunk*) mem_chunk);
}
GRealMemChunk *rmem_chunk;
GMemArea *mem_areas;
GMemArea *temp_area;
-
+
g_assert (mem_chunk != NULL);
-
+
rmem_chunk = (GRealMemChunk*) mem_chunk;
-
+
mem_areas = rmem_chunk->mem_areas;
while (mem_areas)
{
mem_areas = mem_areas->next;
g_free (temp_area);
}
-
+
if (rmem_chunk->next)
rmem_chunk->next->prev = rmem_chunk->prev;
if (rmem_chunk->prev)
rmem_chunk->prev->next = rmem_chunk->next;
-
+
if (rmem_chunk == mem_chunks)
mem_chunks = mem_chunks->next;
-
+
if (rmem_chunk->type == G_ALLOC_AND_FREE)
g_tree_destroy (rmem_chunk->mem_tree);
-
+
g_free (rmem_chunk);
}
GRealMemChunk *rmem_chunk;
GMemArea *temp_area;
gpointer mem;
-
+
g_assert (mem_chunk != NULL);
-
+
rmem_chunk = (GRealMemChunk*) mem_chunk;
-
+
while (rmem_chunk->free_atoms)
{
/* Get the first piece of memory on the "free_atoms" list.
*/
mem = rmem_chunk->free_atoms;
rmem_chunk->free_atoms = rmem_chunk->free_atoms->next;
-
+
/* Determine which area this piece of memory is allocated from */
temp_area = g_tree_search (rmem_chunk->mem_tree,
(GSearchFunc) g_mem_chunk_area_search,
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
{
/* Update the "free" memory available in that area */
temp_area->free += rmem_chunk->atom_size;
-
+
if (temp_area->free == rmem_chunk->area_size)
{
if (temp_area == rmem_chunk->mem_area)
rmem_chunk->mem_area = NULL;
-
+
if (rmem_chunk->free_mem_area)
{
rmem_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 == rmem_chunk->mem_areas)
rmem_chunk->mem_areas = rmem_chunk->mem_areas->next;
-
+
if (rmem_chunk->type == G_ALLOC_AND_FREE)
g_tree_remove (rmem_chunk->mem_tree, temp_area);
g_free (temp_area);
/* 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.
rmem_chunk->mem_area = (GMemArea*) g_malloc (sizeof (GMemArea) -
MEM_AREA_SIZE +
rmem_chunk->area_size);
-
+
rmem_chunk->num_mem_areas += 1;
rmem_chunk->mem_area->next = rmem_chunk->mem_areas;
rmem_chunk->mem_area->prev = NULL;
-
+
if (rmem_chunk->mem_areas)
rmem_chunk->mem_areas->prev = rmem_chunk->mem_area;
rmem_chunk->mem_areas = rmem_chunk->mem_area;
-
+
if (rmem_chunk->type == G_ALLOC_AND_FREE)
g_tree_insert (rmem_chunk->mem_tree, rmem_chunk->mem_area, rmem_chunk->mem_area);
}
-
+
rmem_chunk->mem_area->index = 0;
rmem_chunk->mem_area->free = rmem_chunk->area_size;
rmem_chunk->mem_area->allocated = 0;
rmem_chunk->mem_area->mark = 0;
}
-
+
/* Get the memory and modify the state variables appropriately.
*/
mem = (gpointer) &rmem_chunk->mem_area->mem[rmem_chunk->mem_area->index];
rmem_chunk->mem_area->index += rmem_chunk->atom_size;
rmem_chunk->mem_area->free -= rmem_chunk->atom_size;
rmem_chunk->mem_area->allocated += 1;
-
-outa_here:
+
+ outa_here:
return mem;
}
GRealMemChunk *rmem_chunk;
GMemArea *temp_area;
GFreeAtom *free_atom;
-
+
g_assert (mem_chunk != NULL);
g_assert (mem != NULL);
-
+
rmem_chunk = (GRealMemChunk*) mem_chunk;
-
+
/* Don't do anything if this is an ALLOC_ONLY chunk
*/
if (rmem_chunk->type == G_ALLOC_AND_FREE)
free_atom = (GFreeAtom*) mem;
free_atom->next = rmem_chunk->free_atoms;
rmem_chunk->free_atoms = free_atom;
-
+
temp_area = g_tree_search (rmem_chunk->mem_tree,
(GSearchFunc) g_mem_chunk_area_search,
mem);
-
+
temp_area->allocated -= 1;
-
+
if (temp_area->allocated == 0)
{
temp_area->mark = 1;
GFreeAtom *prev_free_atom;
GFreeAtom *temp_free_atom;
gpointer mem;
-
+
g_assert (mem_chunk != NULL);
-
+
rmem_chunk = (GRealMemChunk*) mem_chunk;
-
+
if (rmem_chunk->type == G_ALLOC_AND_FREE)
{
prev_free_atom = NULL;
temp_free_atom = rmem_chunk->free_atoms;
-
+
while (temp_free_atom)
{
mem = (gpointer) temp_free_atom;
-
+
mem_area = g_tree_search (rmem_chunk->mem_tree,
(GSearchFunc) 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.
*/
else
rmem_chunk->free_atoms = temp_free_atom->next;
temp_free_atom = temp_free_atom->next;
-
+
mem_area->free += rmem_chunk->atom_size;
if (mem_area->free == rmem_chunk->area_size)
{
rmem_chunk->num_mem_areas -= 1;
rmem_chunk->num_marked_areas -= 1;
-
+
if (mem_area->next)
mem_area->next->prev = mem_area->prev;
if (mem_area->prev)
rmem_chunk->mem_areas = rmem_chunk->mem_areas->next;
if (mem_area == rmem_chunk->mem_area)
rmem_chunk->mem_area = NULL;
-
+
if (rmem_chunk->type == G_ALLOC_AND_FREE)
g_tree_remove (rmem_chunk->mem_tree, mem_area);
g_free (mem_area);
GRealMemChunk *rmem_chunk;
GMemArea *mem_areas;
GMemArea *temp_area;
-
+
g_assert (mem_chunk != NULL);
-
+
rmem_chunk = (GRealMemChunk*) mem_chunk;
-
+
mem_areas = rmem_chunk->mem_areas;
rmem_chunk->num_mem_areas = 0;
rmem_chunk->mem_areas = NULL;
rmem_chunk->mem_area = NULL;
-
+
while (mem_areas)
{
temp_area = mem_areas;
mem_areas = mem_areas->next;
g_free (temp_area);
}
-
+
rmem_chunk->free_atoms = NULL;
-
+
if (rmem_chunk->mem_tree)
g_tree_destroy (rmem_chunk->mem_tree);
rmem_chunk->mem_tree = g_tree_new ((GCompareFunc) g_mem_chunk_area_compare);
GRealMemChunk *rmem_chunk;
GMemArea *mem_areas;
gulong mem;
-
+
g_assert (mem_chunk != NULL);
-
+
rmem_chunk = (GRealMemChunk*) mem_chunk;
mem_areas = rmem_chunk->mem_areas;
mem = 0;
-
+
while (mem_areas)
{
mem += rmem_chunk->area_size - mem_areas->free;
mem_areas = mem_areas->next;
}
-
- g_print ("%s: %ld bytes using %d mem areas\n", rmem_chunk->name, mem, rmem_chunk->num_mem_areas);
+
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO,
+ "%s: %ld bytes using %d mem areas\n",
+ rmem_chunk->name, mem, rmem_chunk->num_mem_areas);
}
void
{
GRealMemChunk *mem_chunk;
gint count;
-
+
count = 0;
mem_chunk = mem_chunks;
while (mem_chunk)
count += 1;
mem_chunk = mem_chunk->next;
}
-
- g_print ("%d mem chunks\n", count);
-
+
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%d mem chunks\n", count);
+
mem_chunk = mem_chunks;
while (mem_chunk)
{
g_blow_chunks (void)
{
GRealMemChunk *mem_chunk;
-
+
mem_chunk = mem_chunks;
while (mem_chunk)
{
{
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))
return lower;
return upper;
/* --- variables --- */
const gchar *g_log_domain_glib = "GLib";
static GLogDomain *g_log_domains = NULL;
+static GLogLevelFlags g_log_always_fatal = G_LOG_FATAL_MASK;
static GPrintFunc glib_print_func = NULL;
static GPrintFunc glib_printerr_func = NULL;
static GErrorFunc glib_error_func = NULL;
return g_log_default_handler;
}
+GLogLevelFlags
+g_log_set_always_fatal (GLogLevelFlags fatal_mask)
+{
+ GLogLevelFlags old_mask;
+
+ /* restrict the global mask to levels that are known to glib */
+ fatal_mask &= (1 << G_LOG_LEVEL_USER_SHIFT) - 1;
+ /* force errors to be fatal */
+ fatal_mask |= G_LOG_LEVEL_ERROR;
+ /* remove bogus flag */
+ fatal_mask &= ~G_LOG_FLAG_FATAL;
+
+ old_mask = g_log_always_fatal;
+ g_log_always_fatal = fatal_mask;
+
+ return old_mask;
+}
+
GLogLevelFlags
g_log_set_fatal_mask (const gchar *log_domain,
GLogLevelFlags fatal_mask)
if (g_log_depth++)
test_level |= G_LOG_FLAG_RECURSION;
- if (((domain ? domain->fatal_mask : G_LOG_FATAL_MASK) & test_level) != 0)
+ if ((((domain ? domain->fatal_mask : G_LOG_FATAL_MASK) | g_log_always_fatal) &
+ test_level) != 0)
test_level |= G_LOG_FLAG_FATAL;
log_func = g_log_domain_get_handler (domain, test_level, &data);
log_func (log_domain, test_level, buffer, data);
{
gint fields;
gint current_field;
-
+
GHashTable *all_tuples;
GHashTable **hashed_tuple_tables;
GMemChunk *tuple_chunk;
-
+
gint count;
};
{
gpointer* a = (gpointer*) v_a;
gpointer* b = (gpointer*) v_b;
-
+
return a[0] == b[0] && a[1] == b[1];
}
tuple_hash_2 (gconstpointer v_a)
{
gpointer* a = (gpointer*) v_a;
-
+
return (gulong)a[0] ^ (gulong)a[1];
}
default:
g_error ("no tuple hash for %d", fields);
}
-
+
return NULL;
}
default:
g_error ("no tuple equal for %d", fields);
}
-
+
return NULL;
}
g_relation_new (gint fields)
{
GRealRelation* rel = g_new0 (GRealRelation, 1);
-
+
rel->fields = fields;
rel->tuple_chunk = g_mem_chunk_new ("Relation Chunk",
fields * sizeof (gpointer),
G_ALLOC_AND_FREE);
rel->all_tuples = g_hash_table_new (tuple_hash (fields), tuple_equal (fields));
rel->hashed_tuple_tables = g_new0 (GHashTable*, fields);
-
+
return (GRelation*) rel;
}
{
GRealRelation *rel = (GRealRelation *) relation;
gint i;
-
+
if (rel)
{
g_hash_table_destroy (rel->all_tuples);
g_mem_chunk_destroy (rel->tuple_chunk);
-
+
for (i = 0; i < rel->fields; i += 1)
{
if (rel->hashed_tuple_tables[i])
g_hash_table_destroy (rel->hashed_tuple_tables[i]);
}
}
-
+
g_free (rel->hashed_tuple_tables);
g_free (rel);
}
GCompareFunc key_compare_func)
{
GRealRelation *rel = (GRealRelation *) relation;
-
+
g_assert (rel->count == 0 && rel->hashed_tuple_tables[field] == NULL);
-
+
rel->hashed_tuple_tables[field] = g_hash_table_new (hash_func, key_compare_func);
}
gpointer* tuple = g_chunk_new (gpointer, rel->tuple_chunk);
va_list args;
gint i;
-
+
va_start(args, relation);
-
+
for (i = 0; i < rel->fields; i += 1)
tuple[i] = va_arg(args, gpointer);
-
+
va_end(args);
-
+
g_hash_table_insert (rel->all_tuples, tuple, tuple);
-
+
rel->count += 1;
-
+
for (i = 0; i < rel->fields; i += 1)
{
GHashTable *table;
gpointer key;
GHashTable *per_key_table;
-
+
table = rel->hashed_tuple_tables[i];
-
+
if (table == NULL)
continue;
-
+
key = tuple[i];
per_key_table = g_hash_table_lookup (table, key);
-
+
if (per_key_table == NULL)
{
per_key_table = g_hash_table_new (tuple_hash (rel->fields), tuple_equal (rel->fields));
g_hash_table_insert (table, key, per_key_table);
}
-
+
g_hash_table_insert (per_key_table, tuple, tuple);
}
}
gpointer *tuple = (gpointer*) tuple_value;
GRealRelation *rel = (GRealRelation *) user_data;
gint j;
-
+
g_assert (tuple_key == tuple_value);
-
+
for (j = 0; j < rel->fields; j += 1)
{
GHashTable *one_table = rel->hashed_tuple_tables[j];
gpointer one_key;
GHashTable *per_key_table;
-
+
if (one_table == NULL)
continue;
-
+
if (j == rel->current_field)
/* can't delete from the table we're foreaching in */
continue;
-
+
one_key = tuple[j];
-
+
per_key_table = g_hash_table_lookup (one_table, one_key);
-
+
g_hash_table_remove (per_key_table, tuple);
}
-
+
g_hash_table_remove (rel->all_tuples, tuple);
-
+
rel->count -= 1;
}
GHashTable *table = rel->hashed_tuple_tables[field];
GHashTable *key_table;
gint count = rel->count;
-
+
g_assert (table);
-
+
key_table = g_hash_table_lookup (table, key);
-
+
if (!key_table)
return 0;
-
+
rel->current_field = field;
-
+
g_hash_table_foreach (key_table, g_relation_delete_tuple, rel);
-
+
g_hash_table_remove (table, key);
-
+
g_hash_table_destroy (key_table);
-
- /* @@@ Remove empty hash tables. */
-
+
+ /* @@@ FIXME: Remove empty hash tables. */
+
return count - rel->count;
}
gpointer *tuple = (gpointer*) tuple_value;
GRealTuples *tuples = (GRealTuples*) user_data;
gint stride = sizeof (gpointer) * tuples->width;
-
+
g_assert (tuple_key == tuple_value);
-
+
memcpy (tuples->data + (tuples->len * tuples->width),
tuple,
stride);
-
+
tuples->len += 1;
}
GHashTable *key_table;
GRealTuples *tuples = g_new0 (GRealTuples, 1);
gint count;
-
+
g_assert (table);
-
+
key_table = g_hash_table_lookup (table, key);
-
+
if (!key_table)
return (GTuples*)tuples;
-
+
count = g_relation_count (relation, key, field);
-
+
tuples->data = g_malloc (sizeof (gpointer) * rel->fields * count);
tuples->width = rel->fields;
-
+
g_hash_table_foreach (key_table, g_relation_select_tuple, tuples);
-
+
g_assert (count == tuples->len);
-
+
return (GTuples*)tuples;
}
GRealRelation *rel = (GRealRelation *) relation;
GHashTable *table = rel->hashed_tuple_tables[field];
GHashTable *key_table;
-
+
g_assert (table);
-
+
key_table = g_hash_table_lookup (table, key);
-
+
if (!key_table)
return 0;
-
+
return g_hash_table_size (key_table);
}
va_list args;
gint i;
gboolean result;
-
+
va_start(args, relation);
-
+
for (i = 0; i < rel->fields; i += 1)
tuple[i] = va_arg(args, gpointer);
-
+
va_end(args);
-
+
result = g_hash_table_lookup (rel->all_tuples, tuple) != NULL;
-
+
g_mem_chunk_free (rel->tuple_chunk, tuple);
-
+
return result;
}
g_tuples_destroy (GTuples *tuples0)
{
GRealTuples *tuples = (GRealTuples*) tuples0;
-
+
if (tuples)
{
g_free (tuples->data);
gint field)
{
GRealTuples *tuples = (GRealTuples*) tuples0;
-
+
g_assert (field < tuples->width);
-
+
return tuples->data[index * tuples->width + field];
}
gpointer user_data)
{
gint i;
+ GString *gstring;
GRealRelation* rel = (GRealRelation*) user_data;
gpointer* tuples = (gpointer*) tuple_value;
- g_print ("[");
-
+ gstring = g_string_new ("[");
+
for (i = 0; i < rel->fields; i += 1)
{
- g_print ("%p", tuples[i]);
-
+ g_string_sprintfa (gstring, "%p", tuples[i]);
+
if (i < (rel->fields - 1))
- g_print (",");
+ g_string_append (gstring, ",");
}
-
- g_print ("]\n");
+
+ g_string_append (gstring, "]");
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, gstring->str);
+ g_string_free (gstring, TRUE);
}
static void
{
GRealRelation* rel = (GRealRelation*) user_data;
GHashTable* table = (GHashTable*) tuple_value;
-
- g_print ("*** key %p\n", tuple_key);
-
+
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "*** key %p", tuple_key);
+
g_hash_table_foreach (table,
g_relation_print_one,
rel);
{
gint i;
GRealRelation* rel = (GRealRelation*) relation;
-
- g_print ("*** all tuples (%d)\n", rel->count);
-
+
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "*** all tuples (%d)", rel->count);
+
g_hash_table_foreach (rel->all_tuples,
g_relation_print_one,
rel);
-
+
for (i = 0; i < rel->fields; i += 1)
{
if (rel->hashed_tuple_tables[i] == NULL)
continue;
-
- g_print ("*** index %d\n", i);
-
+
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "*** index %d", i);
+
g_hash_table_foreach (rel->hashed_tuple_tables[i],
g_relation_print_index,
rel);
}
-
+
}
gint left_height;
gint right_height;
gint balance;
-
+
if (node)
{
left_height = 0;
right_height = 0;
-
+
if (node->left)
left_height = g_tree_node_height (node->left);
if (node->right)
right_height = g_tree_node_height (node->right);
-
+
balance = right_height - left_height;
if (balance != node->balance)
- g_print ("g_tree_node_check: failed: %d ( %d )\n",
- balance, node->balance);
-
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO,
+ "g_tree_node_check: failed: %d ( %d )\n",
+ balance, node->balance);
+
if (node->left)
g_tree_node_check (node->left);
if (node->right)
g_malloc (gulong size)
{
gpointer p;
-
-
+
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
gulong *t;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
-
+
+
if (size == 0)
return NULL;
-
-
+
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
size += SIZEOF_LONG;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
+
#ifdef ENABLE_MEM_CHECK
size += SIZEOF_LONG;
#endif /* ENABLE_MEM_CHECK */
-
-
+
+
p = (gpointer) malloc (size);
if (!p)
g_error ("could not allocate %ld bytes", size);
-
-
+
+
#ifdef ENABLE_MEM_CHECK
size -= SIZEOF_LONG;
-
+
t = p;
p = ((guchar*) p + SIZEOF_LONG);
*t = 0;
#endif /* ENABLE_MEM_CHECK */
-
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
size -= SIZEOF_LONG;
-
+
t = p;
p = ((guchar*) p + SIZEOF_LONG);
*t = size;
-
+
#ifdef ENABLE_MEM_PROFILE
if (size <= 4095)
allocations[size-1] += 1;
allocated_mem += size;
#endif /* ENABLE_MEM_PROFILE */
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
-
+
+
return p;
}
g_malloc0 (gulong size)
{
gpointer p;
-
-
+
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
gulong *t;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
-
+
+
if (size == 0)
return NULL;
-
-
+
+
#ifdef ENABLE_MEM_PROFILE
size += SIZEOF_LONG;
#endif /* ENABLE_MEM_PROFILE */
-
+
#ifdef ENABLE_MEM_CHECK
size += SIZEOF_LONG;
#endif /* ENABLE_MEM_CHECK */
-
-
+
+
p = (gpointer) calloc (size, 1);
if (!p)
g_error ("could not allocate %ld bytes", size);
-
-
+
+
#ifdef ENABLE_MEM_CHECK
size -= SIZEOF_LONG;
-
+
t = p;
p = ((guchar*) p + SIZEOF_LONG);
*t = 0;
#endif /* ENABLE_MEM_CHECK */
-
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
size -= SIZEOF_LONG;
-
+
t = p;
p = ((guchar*) p + SIZEOF_LONG);
*t = size;
-
+
#ifdef ENABLE_MEM_PROFILE
if (size <= 4095)
allocations[size-1] += 1;
allocated_mem += size;
#endif /* ENABLE_MEM_PROFILE */
#endif /* ENABLE_MEM_PROFILE */
-
-
+
+
return p;
}
gulong size)
{
gpointer p;
-
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
gulong *t;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
-
+
+
if (size == 0)
return NULL;
-
-
+
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
size += SIZEOF_LONG;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
+
#ifdef ENABLE_MEM_CHECK
size += SIZEOF_LONG;
#endif /* ENABLE_MEM_CHECK */
-
-
+
+
if (!mem)
p = (gpointer) malloc (size);
else
#endif /* ENABLE_MEM_PROFILE */
mem = t;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
+
#ifdef ENABLE_MEM_CHECK
t = (gulong*) ((guchar*) mem - SIZEOF_LONG);
if (*t >= 1)
g_warning ("trying to realloc freed memory\n");
mem = t;
#endif /* ENABLE_MEM_CHECK */
-
+
p = (gpointer) realloc (mem, size);
}
-
+
if (!p)
g_error ("could not reallocate %ld bytes", size);
-
-
+
+
#ifdef ENABLE_MEM_CHECK
size -= SIZEOF_LONG;
-
+
t = p;
p = ((guchar*) p + SIZEOF_LONG);
*t = 0;
#endif /* ENABLE_MEM_CHECK */
-
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
size -= SIZEOF_LONG;
-
+
t = p;
p = ((guchar*) p + SIZEOF_LONG);
*t = size;
-
+
#ifdef ENABLE_MEM_PROFILE
if (size <= 4095)
allocations[size-1] += 1;
allocated_mem += size;
#endif /* ENABLE_MEM_PROFILE */
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
-
+
+
return p;
}
gulong *t;
gulong size;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
+
#if defined(ENABLE_MEM_PROFILE) || defined(ENABLE_MEM_CHECK)
t = (gulong*) ((guchar*) mem - SIZEOF_LONG);
size = *t;
#endif /* ENABLE_MEM_PROFILE */
mem = t;
#endif /* ENABLE_MEM_PROFILE || ENABLE_MEM_CHECK */
-
+
#ifdef ENABLE_MEM_CHECK
t = (gulong*) ((guchar*) mem - SIZEOF_LONG);
if (*t >= 1)
g_warning ("freeing previously freed memory\n");
*t += 1;
mem = t;
-
+
memset ((guchar*) mem + 8, 0, size);
#else /* ENABLE_MEM_CHECK */
free (mem);
{
#ifdef ENABLE_MEM_PROFILE
gint i;
-
+
for (i = 0; i < 4095; i++)
if (allocations[i] > 0)
- g_print ("%lu allocations of %d bytes\n", allocations[i], i + 1);
-
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO,
+ "%lu allocations of %d bytes\n", allocations[i], i + 1);
+
if (allocations[4095] > 0)
- g_print ("%lu allocations of greater than 4095 bytes\n", allocations[4095]);
- g_print ("%lu bytes allocated\n", allocated_mem);
- g_print ("%lu bytes freed\n", freed_mem);
- g_print ("%lu bytes in use\n", allocated_mem - freed_mem);
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO,
+ "%lu allocations of greater than 4095 bytes\n", allocations[4095]);
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%lu bytes allocated\n", allocated_mem);
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%lu bytes freed\n", freed_mem);
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%lu bytes in use\n", allocated_mem - freed_mem);
#endif /* ENABLE_MEM_PROFILE */
}
{
#ifdef ENABLE_MEM_CHECK
gulong *t;
-
+
t = (gulong*) ((guchar*) mem - SIZEOF_LONG - SIZEOF_LONG);
-
+
if (*t >= 1)
g_warning ("mem: 0x%08x has been freed: %lu\n", (gulong) mem, *t);
#endif /* ENABLE_MEM_CHECK */
{
GRealMemChunk *mem_chunk;
gulong rarea_size;
-
+
mem_chunk = g_new (struct _GRealMemChunk, 1);
mem_chunk->name = name;
mem_chunk->type = type;
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 % MEM_ALIGN)
mem_chunk->atom_size += MEM_ALIGN - (mem_chunk->atom_size % MEM_ALIGN);
-
+
mem_chunk->area_size = area_size;
if (mem_chunk->area_size > MAX_MEM_AREA)
mem_chunk->area_size = MAX_MEM_AREA;
while (mem_chunk->area_size < mem_chunk->atom_size)
mem_chunk->area_size *= 2;
-
+
rarea_size = mem_chunk->area_size + sizeof (GMemArea) - MEM_AREA_SIZE;
rarea_size = g_mem_chunk_compute_size (rarea_size);
mem_chunk->area_size = rarea_size - (sizeof (GMemArea) - MEM_AREA_SIZE);
-
+
/*
- mem_chunk->area_size -= (sizeof (GMemArea) - MEM_AREA_SIZE);
- if (mem_chunk->area_size < mem_chunk->atom_size)
+ mem_chunk->area_size -= (sizeof (GMemArea) - MEM_AREA_SIZE);
+ if (mem_chunk->area_size < mem_chunk->atom_size)
{
- mem_chunk->area_size = (mem_chunk->area_size + sizeof (GMemArea) - MEM_AREA_SIZE) * 2;
- mem_chunk->area_size -= (sizeof (GMemArea) - MEM_AREA_SIZE);
+ mem_chunk->area_size = (mem_chunk->area_size + sizeof (GMemArea) - MEM_AREA_SIZE) * 2;
+ mem_chunk->area_size -= (sizeof (GMemArea) - MEM_AREA_SIZE);
}
-
- if (mem_chunk->area_size % mem_chunk->atom_size)
+
+ if (mem_chunk->area_size % mem_chunk->atom_size)
mem_chunk->area_size += mem_chunk->atom_size - (mem_chunk->area_size % mem_chunk->atom_size);
- */
-
+ */
+
mem_chunk->next = mem_chunks;
mem_chunk->prev = NULL;
if (mem_chunks)
mem_chunks->prev = mem_chunk;
mem_chunks = mem_chunk;
-
+
return ((GMemChunk*) mem_chunk);
}
GRealMemChunk *rmem_chunk;
GMemArea *mem_areas;
GMemArea *temp_area;
-
+
g_assert (mem_chunk != NULL);
-
+
rmem_chunk = (GRealMemChunk*) mem_chunk;
-
+
mem_areas = rmem_chunk->mem_areas;
while (mem_areas)
{
mem_areas = mem_areas->next;
g_free (temp_area);
}
-
+
if (rmem_chunk->next)
rmem_chunk->next->prev = rmem_chunk->prev;
if (rmem_chunk->prev)
rmem_chunk->prev->next = rmem_chunk->next;
-
+
if (rmem_chunk == mem_chunks)
mem_chunks = mem_chunks->next;
-
+
if (rmem_chunk->type == G_ALLOC_AND_FREE)
g_tree_destroy (rmem_chunk->mem_tree);
-
+
g_free (rmem_chunk);
}
GRealMemChunk *rmem_chunk;
GMemArea *temp_area;
gpointer mem;
-
+
g_assert (mem_chunk != NULL);
-
+
rmem_chunk = (GRealMemChunk*) mem_chunk;
-
+
while (rmem_chunk->free_atoms)
{
/* Get the first piece of memory on the "free_atoms" list.
*/
mem = rmem_chunk->free_atoms;
rmem_chunk->free_atoms = rmem_chunk->free_atoms->next;
-
+
/* Determine which area this piece of memory is allocated from */
temp_area = g_tree_search (rmem_chunk->mem_tree,
(GSearchFunc) g_mem_chunk_area_search,
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
{
/* Update the "free" memory available in that area */
temp_area->free += rmem_chunk->atom_size;
-
+
if (temp_area->free == rmem_chunk->area_size)
{
if (temp_area == rmem_chunk->mem_area)
rmem_chunk->mem_area = NULL;
-
+
if (rmem_chunk->free_mem_area)
{
rmem_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 == rmem_chunk->mem_areas)
rmem_chunk->mem_areas = rmem_chunk->mem_areas->next;
-
+
if (rmem_chunk->type == G_ALLOC_AND_FREE)
g_tree_remove (rmem_chunk->mem_tree, temp_area);
g_free (temp_area);
/* 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.
rmem_chunk->mem_area = (GMemArea*) g_malloc (sizeof (GMemArea) -
MEM_AREA_SIZE +
rmem_chunk->area_size);
-
+
rmem_chunk->num_mem_areas += 1;
rmem_chunk->mem_area->next = rmem_chunk->mem_areas;
rmem_chunk->mem_area->prev = NULL;
-
+
if (rmem_chunk->mem_areas)
rmem_chunk->mem_areas->prev = rmem_chunk->mem_area;
rmem_chunk->mem_areas = rmem_chunk->mem_area;
-
+
if (rmem_chunk->type == G_ALLOC_AND_FREE)
g_tree_insert (rmem_chunk->mem_tree, rmem_chunk->mem_area, rmem_chunk->mem_area);
}
-
+
rmem_chunk->mem_area->index = 0;
rmem_chunk->mem_area->free = rmem_chunk->area_size;
rmem_chunk->mem_area->allocated = 0;
rmem_chunk->mem_area->mark = 0;
}
-
+
/* Get the memory and modify the state variables appropriately.
*/
mem = (gpointer) &rmem_chunk->mem_area->mem[rmem_chunk->mem_area->index];
rmem_chunk->mem_area->index += rmem_chunk->atom_size;
rmem_chunk->mem_area->free -= rmem_chunk->atom_size;
rmem_chunk->mem_area->allocated += 1;
-
-outa_here:
+
+ outa_here:
return mem;
}
GRealMemChunk *rmem_chunk;
GMemArea *temp_area;
GFreeAtom *free_atom;
-
+
g_assert (mem_chunk != NULL);
g_assert (mem != NULL);
-
+
rmem_chunk = (GRealMemChunk*) mem_chunk;
-
+
/* Don't do anything if this is an ALLOC_ONLY chunk
*/
if (rmem_chunk->type == G_ALLOC_AND_FREE)
free_atom = (GFreeAtom*) mem;
free_atom->next = rmem_chunk->free_atoms;
rmem_chunk->free_atoms = free_atom;
-
+
temp_area = g_tree_search (rmem_chunk->mem_tree,
(GSearchFunc) g_mem_chunk_area_search,
mem);
-
+
temp_area->allocated -= 1;
-
+
if (temp_area->allocated == 0)
{
temp_area->mark = 1;
GFreeAtom *prev_free_atom;
GFreeAtom *temp_free_atom;
gpointer mem;
-
+
g_assert (mem_chunk != NULL);
-
+
rmem_chunk = (GRealMemChunk*) mem_chunk;
-
+
if (rmem_chunk->type == G_ALLOC_AND_FREE)
{
prev_free_atom = NULL;
temp_free_atom = rmem_chunk->free_atoms;
-
+
while (temp_free_atom)
{
mem = (gpointer) temp_free_atom;
-
+
mem_area = g_tree_search (rmem_chunk->mem_tree,
(GSearchFunc) 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.
*/
else
rmem_chunk->free_atoms = temp_free_atom->next;
temp_free_atom = temp_free_atom->next;
-
+
mem_area->free += rmem_chunk->atom_size;
if (mem_area->free == rmem_chunk->area_size)
{
rmem_chunk->num_mem_areas -= 1;
rmem_chunk->num_marked_areas -= 1;
-
+
if (mem_area->next)
mem_area->next->prev = mem_area->prev;
if (mem_area->prev)
rmem_chunk->mem_areas = rmem_chunk->mem_areas->next;
if (mem_area == rmem_chunk->mem_area)
rmem_chunk->mem_area = NULL;
-
+
if (rmem_chunk->type == G_ALLOC_AND_FREE)
g_tree_remove (rmem_chunk->mem_tree, mem_area);
g_free (mem_area);
GRealMemChunk *rmem_chunk;
GMemArea *mem_areas;
GMemArea *temp_area;
-
+
g_assert (mem_chunk != NULL);
-
+
rmem_chunk = (GRealMemChunk*) mem_chunk;
-
+
mem_areas = rmem_chunk->mem_areas;
rmem_chunk->num_mem_areas = 0;
rmem_chunk->mem_areas = NULL;
rmem_chunk->mem_area = NULL;
-
+
while (mem_areas)
{
temp_area = mem_areas;
mem_areas = mem_areas->next;
g_free (temp_area);
}
-
+
rmem_chunk->free_atoms = NULL;
-
+
if (rmem_chunk->mem_tree)
g_tree_destroy (rmem_chunk->mem_tree);
rmem_chunk->mem_tree = g_tree_new ((GCompareFunc) g_mem_chunk_area_compare);
GRealMemChunk *rmem_chunk;
GMemArea *mem_areas;
gulong mem;
-
+
g_assert (mem_chunk != NULL);
-
+
rmem_chunk = (GRealMemChunk*) mem_chunk;
mem_areas = rmem_chunk->mem_areas;
mem = 0;
-
+
while (mem_areas)
{
mem += rmem_chunk->area_size - mem_areas->free;
mem_areas = mem_areas->next;
}
-
- g_print ("%s: %ld bytes using %d mem areas\n", rmem_chunk->name, mem, rmem_chunk->num_mem_areas);
+
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO,
+ "%s: %ld bytes using %d mem areas\n",
+ rmem_chunk->name, mem, rmem_chunk->num_mem_areas);
}
void
{
GRealMemChunk *mem_chunk;
gint count;
-
+
count = 0;
mem_chunk = mem_chunks;
while (mem_chunk)
count += 1;
mem_chunk = mem_chunk->next;
}
-
- g_print ("%d mem chunks\n", count);
-
+
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "%d mem chunks\n", count);
+
mem_chunk = mem_chunks;
while (mem_chunk)
{
g_blow_chunks (void)
{
GRealMemChunk *mem_chunk;
-
+
mem_chunk = mem_chunks;
while (mem_chunk)
{
{
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))
return lower;
return upper;
/* --- variables --- */
const gchar *g_log_domain_glib = "GLib";
static GLogDomain *g_log_domains = NULL;
+static GLogLevelFlags g_log_always_fatal = G_LOG_FATAL_MASK;
static GPrintFunc glib_print_func = NULL;
static GPrintFunc glib_printerr_func = NULL;
static GErrorFunc glib_error_func = NULL;
return g_log_default_handler;
}
+GLogLevelFlags
+g_log_set_always_fatal (GLogLevelFlags fatal_mask)
+{
+ GLogLevelFlags old_mask;
+
+ /* restrict the global mask to levels that are known to glib */
+ fatal_mask &= (1 << G_LOG_LEVEL_USER_SHIFT) - 1;
+ /* force errors to be fatal */
+ fatal_mask |= G_LOG_LEVEL_ERROR;
+ /* remove bogus flag */
+ fatal_mask &= ~G_LOG_FLAG_FATAL;
+
+ old_mask = g_log_always_fatal;
+ g_log_always_fatal = fatal_mask;
+
+ return old_mask;
+}
+
GLogLevelFlags
g_log_set_fatal_mask (const gchar *log_domain,
GLogLevelFlags fatal_mask)
if (g_log_depth++)
test_level |= G_LOG_FLAG_RECURSION;
- if (((domain ? domain->fatal_mask : G_LOG_FATAL_MASK) & test_level) != 0)
+ if ((((domain ? domain->fatal_mask : G_LOG_FATAL_MASK) | g_log_always_fatal) &
+ test_level) != 0)
test_level |= G_LOG_FLAG_FATAL;
log_func = g_log_domain_get_handler (domain, test_level, &data);
log_func (log_domain, test_level, buffer, data);
{
gint fields;
gint current_field;
-
+
GHashTable *all_tuples;
GHashTable **hashed_tuple_tables;
GMemChunk *tuple_chunk;
-
+
gint count;
};
{
gpointer* a = (gpointer*) v_a;
gpointer* b = (gpointer*) v_b;
-
+
return a[0] == b[0] && a[1] == b[1];
}
tuple_hash_2 (gconstpointer v_a)
{
gpointer* a = (gpointer*) v_a;
-
+
return (gulong)a[0] ^ (gulong)a[1];
}
default:
g_error ("no tuple hash for %d", fields);
}
-
+
return NULL;
}
default:
g_error ("no tuple equal for %d", fields);
}
-
+
return NULL;
}
g_relation_new (gint fields)
{
GRealRelation* rel = g_new0 (GRealRelation, 1);
-
+
rel->fields = fields;
rel->tuple_chunk = g_mem_chunk_new ("Relation Chunk",
fields * sizeof (gpointer),
G_ALLOC_AND_FREE);
rel->all_tuples = g_hash_table_new (tuple_hash (fields), tuple_equal (fields));
rel->hashed_tuple_tables = g_new0 (GHashTable*, fields);
-
+
return (GRelation*) rel;
}
{
GRealRelation *rel = (GRealRelation *) relation;
gint i;
-
+
if (rel)
{
g_hash_table_destroy (rel->all_tuples);
g_mem_chunk_destroy (rel->tuple_chunk);
-
+
for (i = 0; i < rel->fields; i += 1)
{
if (rel->hashed_tuple_tables[i])
g_hash_table_destroy (rel->hashed_tuple_tables[i]);
}
}
-
+
g_free (rel->hashed_tuple_tables);
g_free (rel);
}
GCompareFunc key_compare_func)
{
GRealRelation *rel = (GRealRelation *) relation;
-
+
g_assert (rel->count == 0 && rel->hashed_tuple_tables[field] == NULL);
-
+
rel->hashed_tuple_tables[field] = g_hash_table_new (hash_func, key_compare_func);
}
gpointer* tuple = g_chunk_new (gpointer, rel->tuple_chunk);
va_list args;
gint i;
-
+
va_start(args, relation);
-
+
for (i = 0; i < rel->fields; i += 1)
tuple[i] = va_arg(args, gpointer);
-
+
va_end(args);
-
+
g_hash_table_insert (rel->all_tuples, tuple, tuple);
-
+
rel->count += 1;
-
+
for (i = 0; i < rel->fields; i += 1)
{
GHashTable *table;
gpointer key;
GHashTable *per_key_table;
-
+
table = rel->hashed_tuple_tables[i];
-
+
if (table == NULL)
continue;
-
+
key = tuple[i];
per_key_table = g_hash_table_lookup (table, key);
-
+
if (per_key_table == NULL)
{
per_key_table = g_hash_table_new (tuple_hash (rel->fields), tuple_equal (rel->fields));
g_hash_table_insert (table, key, per_key_table);
}
-
+
g_hash_table_insert (per_key_table, tuple, tuple);
}
}
gpointer *tuple = (gpointer*) tuple_value;
GRealRelation *rel = (GRealRelation *) user_data;
gint j;
-
+
g_assert (tuple_key == tuple_value);
-
+
for (j = 0; j < rel->fields; j += 1)
{
GHashTable *one_table = rel->hashed_tuple_tables[j];
gpointer one_key;
GHashTable *per_key_table;
-
+
if (one_table == NULL)
continue;
-
+
if (j == rel->current_field)
/* can't delete from the table we're foreaching in */
continue;
-
+
one_key = tuple[j];
-
+
per_key_table = g_hash_table_lookup (one_table, one_key);
-
+
g_hash_table_remove (per_key_table, tuple);
}
-
+
g_hash_table_remove (rel->all_tuples, tuple);
-
+
rel->count -= 1;
}
GHashTable *table = rel->hashed_tuple_tables[field];
GHashTable *key_table;
gint count = rel->count;
-
+
g_assert (table);
-
+
key_table = g_hash_table_lookup (table, key);
-
+
if (!key_table)
return 0;
-
+
rel->current_field = field;
-
+
g_hash_table_foreach (key_table, g_relation_delete_tuple, rel);
-
+
g_hash_table_remove (table, key);
-
+
g_hash_table_destroy (key_table);
-
- /* @@@ Remove empty hash tables. */
-
+
+ /* @@@ FIXME: Remove empty hash tables. */
+
return count - rel->count;
}
gpointer *tuple = (gpointer*) tuple_value;
GRealTuples *tuples = (GRealTuples*) user_data;
gint stride = sizeof (gpointer) * tuples->width;
-
+
g_assert (tuple_key == tuple_value);
-
+
memcpy (tuples->data + (tuples->len * tuples->width),
tuple,
stride);
-
+
tuples->len += 1;
}
GHashTable *key_table;
GRealTuples *tuples = g_new0 (GRealTuples, 1);
gint count;
-
+
g_assert (table);
-
+
key_table = g_hash_table_lookup (table, key);
-
+
if (!key_table)
return (GTuples*)tuples;
-
+
count = g_relation_count (relation, key, field);
-
+
tuples->data = g_malloc (sizeof (gpointer) * rel->fields * count);
tuples->width = rel->fields;
-
+
g_hash_table_foreach (key_table, g_relation_select_tuple, tuples);
-
+
g_assert (count == tuples->len);
-
+
return (GTuples*)tuples;
}
GRealRelation *rel = (GRealRelation *) relation;
GHashTable *table = rel->hashed_tuple_tables[field];
GHashTable *key_table;
-
+
g_assert (table);
-
+
key_table = g_hash_table_lookup (table, key);
-
+
if (!key_table)
return 0;
-
+
return g_hash_table_size (key_table);
}
va_list args;
gint i;
gboolean result;
-
+
va_start(args, relation);
-
+
for (i = 0; i < rel->fields; i += 1)
tuple[i] = va_arg(args, gpointer);
-
+
va_end(args);
-
+
result = g_hash_table_lookup (rel->all_tuples, tuple) != NULL;
-
+
g_mem_chunk_free (rel->tuple_chunk, tuple);
-
+
return result;
}
g_tuples_destroy (GTuples *tuples0)
{
GRealTuples *tuples = (GRealTuples*) tuples0;
-
+
if (tuples)
{
g_free (tuples->data);
gint field)
{
GRealTuples *tuples = (GRealTuples*) tuples0;
-
+
g_assert (field < tuples->width);
-
+
return tuples->data[index * tuples->width + field];
}
gpointer user_data)
{
gint i;
+ GString *gstring;
GRealRelation* rel = (GRealRelation*) user_data;
gpointer* tuples = (gpointer*) tuple_value;
- g_print ("[");
-
+ gstring = g_string_new ("[");
+
for (i = 0; i < rel->fields; i += 1)
{
- g_print ("%p", tuples[i]);
-
+ g_string_sprintfa (gstring, "%p", tuples[i]);
+
if (i < (rel->fields - 1))
- g_print (",");
+ g_string_append (gstring, ",");
}
-
- g_print ("]\n");
+
+ g_string_append (gstring, "]");
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, gstring->str);
+ g_string_free (gstring, TRUE);
}
static void
{
GRealRelation* rel = (GRealRelation*) user_data;
GHashTable* table = (GHashTable*) tuple_value;
-
- g_print ("*** key %p\n", tuple_key);
-
+
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "*** key %p", tuple_key);
+
g_hash_table_foreach (table,
g_relation_print_one,
rel);
{
gint i;
GRealRelation* rel = (GRealRelation*) relation;
-
- g_print ("*** all tuples (%d)\n", rel->count);
-
+
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "*** all tuples (%d)", rel->count);
+
g_hash_table_foreach (rel->all_tuples,
g_relation_print_one,
rel);
-
+
for (i = 0; i < rel->fields; i += 1)
{
if (rel->hashed_tuple_tables[i] == NULL)
continue;
-
- g_print ("*** index %d\n", i);
-
+
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO, "*** index %d", i);
+
g_hash_table_foreach (rel->hashed_tuple_tables[i],
g_relation_print_index,
rel);
}
-
+
}
gint left_height;
gint right_height;
gint balance;
-
+
if (node)
{
left_height = 0;
right_height = 0;
-
+
if (node->left)
left_height = g_tree_node_height (node->left);
if (node->right)
right_height = g_tree_node_height (node->right);
-
+
balance = right_height - left_height;
if (balance != node->balance)
- g_print ("g_tree_node_check: failed: %d ( %d )\n",
- balance, node->balance);
-
+ g_log (g_log_domain_glib, G_LOG_LEVEL_INFO,
+ "g_tree_node_check: failed: %d ( %d )\n",
+ balance, node->balance);
+
if (node->left)
g_tree_node_check (node->left);
if (node->right)
projects / platform / upstream / glib.git / commitdiff