[svn:parrot] r41015 - in branches/gc-refactor: docs docs/pdds include/parrot src/gc t/op
jrtayloriv at svn.parrot.org
jrtayloriv at svn.parrot.org
Sat Sep 5 20:20:33 UTC 2009
Author: jrtayloriv
Date: Sat Sep 5 20:20:31 2009
New Revision: 41015
URL: https://trac.parrot.org/parrot/changeset/41015
Log:
gave sensible names to Small_Obj_Pool and Memory_Pool
Modified:
branches/gc-refactor/docs/memory_internals.pod
branches/gc-refactor/docs/pdds/pdd09_gc.pod
branches/gc-refactor/include/parrot/gc_api.h
branches/gc-refactor/src/gc/alloc_resources.c
branches/gc-refactor/src/gc/api.c
branches/gc-refactor/src/gc/gc_inf.c
branches/gc-refactor/src/gc/gc_malloc.c
branches/gc-refactor/src/gc/gc_ms.c
branches/gc-refactor/src/gc/gc_private.h
branches/gc-refactor/src/gc/generational_ms.c
branches/gc-refactor/src/gc/generational_ms.h
branches/gc-refactor/src/gc/incremental_ms.c
branches/gc-refactor/src/gc/mark_sweep.c
branches/gc-refactor/t/op/gc.t
Modified: branches/gc-refactor/docs/memory_internals.pod
==============================================================================
--- branches/gc-refactor/docs/memory_internals.pod Sat Sep 5 19:45:25 2009 (r41014)
+++ branches/gc-refactor/docs/memory_internals.pod Sat Sep 5 20:20:31 2009 (r41015)
@@ -65,17 +65,17 @@
memory. A simplification looks similar to this:
typedef struct Arenas {
- struct Memory_Pool *memory_pool;
+ struct Var_Size_Obj_Pool *memory_pool;
...
- struct Small_Object_Pool * header_pool;
- struct Small_Object_Pool ** sized_pools;
+ struct Fixed_Size_Obj_Pool * header_pool;
+ struct Fixed_Size_Obj_Pool ** sized_pools;
} Arenas;
C<memory_pool> and C<header_pool> are variable and fixed sized pool pointers
-respectively. These are just two examples, there are other C<Memory_Pool>s
-and C<Small_Object_Pool>s in the Parrot system. Pools of type
-C<struct Memory_Pool> are for variable-size objects, such as constant string
-buffers. Pools of type C<struct Small_Object_Pool> are for fixed-size objects
+respectively. These are just two examples, there are other C<Var_Size_Obj_Pool>s
+and C<Fixed_Size_Obj_Pool>s in the Parrot system. Pools of type
+C<struct Var_Size_Obj_Pool> are for variable-size objects, such as constant string
+buffers. Pools of type C<struct Fixed_Size_Obj_Pool> are for fixed-size objects
such as headers or PMCs.
=head1 Fixed sized items
Modified: branches/gc-refactor/docs/pdds/pdd09_gc.pod
==============================================================================
--- branches/gc-refactor/docs/pdds/pdd09_gc.pod Sat Sep 5 19:45:25 2009 (r41014)
+++ branches/gc-refactor/docs/pdds/pdd09_gc.pod Sat Sep 5 20:20:31 2009 (r41015)
@@ -297,8 +297,8 @@
=head4 The Arenas structure
The Arenas structure contains pointers to a variety of memory pools, each used
-for a specific purpose. Two are Memory_Pool pointers (memory_pool,
-constant_string_pool), and six are Small_Object_Pool structures (pmc_pool,
+for a specific purpose. Two are Var_Size_Obj_Pool pointers (memory_pool,
+constant_string_pool), and six are Fixed_Size_Obj_Pool structures (pmc_pool,
constant_pmc_pool, constant_string_header_pool).
The Arenas structure holds function pointers for the core defined interface of
@@ -312,19 +312,19 @@
The pointer C<void *gc_private> is reserved for use by the currently active GC
subsystem (with freedom for variation between GC implementations).
-=head4 The Memory_Pool structure
+=head4 The Var_Size_Obj_Pool structure
-The Memory_Pool structure is a simple memory pool. It contains a pointer to
+The Var_Size_Obj_Pool structure is a simple memory pool. It contains a pointer to
the top block of the allocated pool, the total allocated size of the pool, the
block size, and some details on the reclamation characteristics of the pool.
-=head4 The Small_Object_Pool structure
+=head4 The Fixed_Size_Obj_Pool structure
-The Small_Object_Pool structure is a richer memory pool for object allocation.
+The Fixed_Size_Obj_Pool structure is a richer memory pool for object allocation.
It tracks details like the number of allocated and free objects in the pool, a
list of free objects, and for the generational GC implementation maintains
linked lists of white, black, and gray PMCs. It contains a pointer to a simple
-Memory_Pool (the base storage of the pool). It holds function pointers for
+Var_Size_Obj_Pool (the base storage of the pool). It holds function pointers for
adding and retrieving free objects in the pool, and for allocating objects.
=head3 Internal API
@@ -432,23 +432,23 @@
All PMCs must be swept, and PMCs with custom destroy VTABLE methods must have
those called.
-=item C<void (*init_pool) (Interp *, Small_Object_Pool *)>
+=item C<void (*init_pool) (Interp *, Fixed_Size_Obj_Pool *)>
-Initialize the given pool. Populates the C<Small_Object_Pool> structure with
+Initialize the given pool. Populates the C<Fixed_Size_Obj_Pool> structure with
initial values, and sets a series of function pointers for working with the
pool. The function pointers used with the pool are discussed next.
=back
-=head4 Small_Object_Pool function pointers
+=head4 Fixed_Size_Obj_Pool function pointers
-Each GC core defines 4 function pointers stored in the C<Small_Object_Pool>
+Each GC core defines 4 function pointers stored in the C<Fixed_Size_Obj_Pool>
structures. These function pointers are used throughout Parrot to implement
basic behaviors for the pool.
=over 4
-=item C<PObj * (*get_free_object) (Interp *, Small_Object_Pool*)>
+=item C<PObj * (*get_free_object) (Interp *, Fixed_Size_Obj_Pool*)>
Get a free object from the pool. This function returns one free object from
the given pool and removes that object from the pool's free list. PObject
@@ -456,20 +456,20 @@
itself, if any. If the pool is a buffer header pool all other object memory
is zeroed.
-=item C<void (*add_free_object) (Interp *, Small_Object_Pool *, PObj *);>
+=item C<void (*add_free_object) (Interp *, Fixed_Size_Obj_Pool *, PObj *);>
Add a freed object to the pool's free list. This function is most often called
internally to the GC itself to add items to the free list after a sweep, or
when a new arena is created to add the new items to the free list. It does
not need to be used in this way, however.
-=item C<void (*alloc_objects) (Interp *, Small_Object_Pool *);>
+=item C<void (*alloc_objects) (Interp *, Fixed_Size_Obj_Pool *);>
Allocate a new arena of objects for the pool. Initialize the new arena and add
all new objects to the pool's free list. Some collectors implement a growth
factor which increases the size of each new allocated arena.
-=item C<void (*more_objects) (Interp *, Small_Object_Pool *);>
+=item C<void (*more_objects) (Interp *, Fixed_Size_Obj_Pool *);>
Reallocation for additional objects. It has the same signature as
C<alloc_objects>, and in some GC cores the same function pointer is used for
Modified: branches/gc-refactor/include/parrot/gc_api.h
==============================================================================
--- branches/gc-refactor/include/parrot/gc_api.h Sat Sep 5 19:45:25 2009 (r41014)
+++ branches/gc-refactor/include/parrot/gc_api.h Sat Sep 5 20:20:31 2009 (r41015)
@@ -52,11 +52,11 @@
POOL_ALL = 0x07
} pool_iter_enum;
-struct Small_Object_Pool;
-struct Small_Object_Arena;
+struct Fixed_Size_Obj_Pool;
+struct Fixed_Size_Obj_Arena;
struct Arenas;
-typedef int (*pool_iter_fn)(PARROT_INTERP, struct Small_Object_Pool *, int, void*);
+typedef int (*pool_iter_fn)(PARROT_INTERP, struct Fixed_Size_Obj_Pool *, int, void*);
typedef struct Memory_Block {
size_t free;
@@ -67,16 +67,16 @@
char *top;
} Memory_Block;
-typedef struct Memory_Pool {
+typedef struct Var_Size_Obj_Pool {
Memory_Block *top_block;
- void (*compact)(PARROT_INTERP, struct Memory_Pool *);
+ void (*compact)(PARROT_INTERP, struct Var_Size_Obj_Pool *);
size_t minimum_block_size;
size_t total_allocated; /* total bytes allocated to this pool */
size_t guaranteed_reclaimable; /* bytes that can definitely be reclaimed*/
size_t possibly_reclaimable; /* bytes that can possibly be reclaimed
* (above plus COW-freed bytes) */
FLOATVAL reclaim_factor; /* minimum percentage we will reclaim */
-} Memory_Pool;
+} Var_Size_Obj_Pool;
typedef enum {
GC_TRACE_FULL = 1,
@@ -84,10 +84,10 @@
GC_TRACE_SYSTEM_ONLY = 3
} Parrot_gc_trace_type;
-typedef void (*add_free_object_fn_type)(PARROT_INTERP, struct Small_Object_Pool *, void *);
-typedef void * (*get_free_object_fn_type)(PARROT_INTERP, struct Small_Object_Pool *);
-typedef void (*alloc_objects_fn_type)(PARROT_INTERP, struct Small_Object_Pool *);
-typedef void (*gc_object_fn_type)(PARROT_INTERP, struct Small_Object_Pool *, PObj *);
+typedef void (*add_free_object_fn_type)(PARROT_INTERP, struct Fixed_Size_Obj_Pool *, void *);
+typedef void * (*get_free_object_fn_type)(PARROT_INTERP, struct Fixed_Size_Obj_Pool *);
+typedef void (*alloc_objects_fn_type)(PARROT_INTERP, struct Fixed_Size_Obj_Pool *);
+typedef void (*gc_object_fn_type)(PARROT_INTERP, struct Fixed_Size_Obj_Pool *, PObj *);
/* &gen_from_enum(interpinfo.pasm) prefix(INTERPINFO_) */
Modified: branches/gc-refactor/src/gc/alloc_resources.c
==============================================================================
--- branches/gc-refactor/src/gc/alloc_resources.c Sat Sep 5 19:45:25 2009 (r41014)
+++ branches/gc-refactor/src/gc/alloc_resources.c Sat Sep 5 20:20:31 2009 (r41015)
@@ -32,7 +32,7 @@
#define POOL_SIZE 65536 * 2
-typedef void (*compact_f) (Interp *, Memory_Pool *);
+typedef void (*compact_f) (Interp *, Var_Size_Obj_Pool *);
/* HEADERIZER HFILE: src/gc/gc_private.h */
@@ -41,7 +41,7 @@
static void alloc_new_block(PARROT_INTERP,
size_t size,
- ARGMOD(Memory_Pool *pool),
+ ARGMOD(Var_Size_Obj_Pool *pool),
ARGIN(const char *why))
__attribute__nonnull__(1)
__attribute__nonnull__(3)
@@ -54,14 +54,14 @@
__attribute__nonnull__(1)
__attribute__nonnull__(2);
-static void check_memory_pool(ARGMOD(Memory_Pool *pool))
+static void check_var_size_obj_pool(ARGMOD(Var_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
FUNC_MODIFIES(*pool);
static void check_memory_system(PARROT_INTERP)
__attribute__nonnull__(1);
-static void check_small_object_pool(ARGMOD(Small_Object_Pool * pool))
+static void check_fixed_size_obj_pool(ARGMOD(Fixed_Size_Obj_Pool * pool))
__attribute__nonnull__(1)
FUNC_MODIFIES(* pool);
@@ -71,7 +71,7 @@
PARROT_MALLOC
PARROT_CANNOT_RETURN_NULL
-static Memory_Pool * new_memory_pool(
+static Var_Size_Obj_Pool * new_memory_pool(
size_t min_block,
NULLOK(compact_f compact));
@@ -82,11 +82,11 @@
#define ASSERT_ARGS_buffer_location __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(interp) \
|| PARROT_ASSERT_ARG(b)
-#define ASSERT_ARGS_check_memory_pool __attribute__unused__ int _ASSERT_ARGS_CHECK = \
+#define ASSERT_ARGS_check_var_size_obj_pool __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(pool)
#define ASSERT_ARGS_check_memory_system __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(interp)
-#define ASSERT_ARGS_check_small_object_pool __attribute__unused__ int _ASSERT_ARGS_CHECK = \
+#define ASSERT_ARGS_check_fixed_size_obj_pool __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(pool)
#define ASSERT_ARGS_debug_print_buf __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(interp) \
@@ -98,7 +98,7 @@
/*
-=item C<static void alloc_new_block(PARROT_INTERP, size_t size, Memory_Pool
+=item C<static void alloc_new_block(PARROT_INTERP, size_t size, Var_Size_Obj_Pool
*pool, const char *why)>
Allocate a new memory block. We allocate either the requested size or the
@@ -110,7 +110,7 @@
*/
static void
-alloc_new_block(PARROT_INTERP, size_t size, ARGMOD(Memory_Pool *pool),
+alloc_new_block(PARROT_INTERP, size_t size, ARGMOD(Var_Size_Obj_Pool *pool),
ARGIN(const char *why))
{
ASSERT_ARGS(alloc_new_block)
@@ -158,7 +158,7 @@
/*
-=item C<void * mem_allocate(PARROT_INTERP, size_t size, Memory_Pool *pool)>
+=item C<void * mem_allocate(PARROT_INTERP, size_t size, Var_Size_Obj_Pool *pool)>
Allocates memory for headers.
@@ -196,7 +196,7 @@
PARROT_MALLOC
PARROT_CANNOT_RETURN_NULL
void *
-mem_allocate(PARROT_INTERP, size_t size, ARGMOD(Memory_Pool *pool))
+mem_allocate(PARROT_INTERP, size_t size, ARGMOD(Var_Size_Obj_Pool *pool))
{
ASSERT_ARGS(mem_allocate)
void *return_val;
@@ -319,7 +319,7 @@
=over 4
-=item C<void compact_pool(PARROT_INTERP, Memory_Pool *pool)>
+=item C<void compact_pool(PARROT_INTERP, Var_Size_Obj_Pool *pool)>
Compact the string buffer pool. Does not perform a GC scan, or mark items
as being alive in any way.
@@ -329,7 +329,7 @@
*/
void
-compact_pool(PARROT_INTERP, ARGMOD(Memory_Pool *pool))
+compact_pool(PARROT_INTERP, ARGMOD(Var_Size_Obj_Pool *pool))
{
ASSERT_ARGS(compact_pool)
INTVAL j;
@@ -338,7 +338,7 @@
Memory_Block *new_block; /* A pointer to our working block */
char *cur_spot; /* Where we're currently copying to */
- Small_Object_Arena *cur_buffer_arena;
+ Fixed_Size_Obj_Arena *cur_buffer_arena;
Arenas * const arena_base = interp->arena_base;
/* Bail if we're blocked */
@@ -406,7 +406,7 @@
/* Run through all the Buffer header pools and copy */
for (j = (INTVAL)arena_base->num_sized - 1; j >= 0; --j) {
- Small_Object_Pool * const header_pool = arena_base->sized_header_pools[j];
+ Fixed_Size_Obj_Pool * const header_pool = arena_base->sized_header_pools[j];
UINTVAL object_size;
if (!header_pool)
@@ -653,10 +653,10 @@
=over 4
-=item C<static Memory_Pool * new_memory_pool(size_t min_block, compact_f
+=item C<static Var_Size_Obj_Pool * new_memory_pool(size_t min_block, compact_f
compact)>
-Allocate a new C<Memory_Pool> structures, and set some initial values.
+Allocate a new C<Var_Size_Obj_Pool> structures, and set some initial values.
return a pointer to the new pool.
=cut
@@ -665,11 +665,11 @@
PARROT_MALLOC
PARROT_CANNOT_RETURN_NULL
-static Memory_Pool *
+static Var_Size_Obj_Pool *
new_memory_pool(size_t min_block, NULLOK(compact_f compact))
{
ASSERT_ARGS(new_memory_pool)
- Memory_Pool * const pool = mem_internal_allocate_typed(Memory_Pool);
+ Var_Size_Obj_Pool * const pool = mem_internal_allocate_typed(Var_Size_Obj_Pool);
pool->top_block = NULL;
pool->compact = compact;
@@ -686,7 +686,7 @@
=item C<void initialize_memory_pools(PARROT_INTERP)>
-Initialize the managed memory pools. Parrot maintains two C<Memory_Pool>
+Initialize the managed memory pools. Parrot maintains two C<Var_Size_Obj_Pool>
structures, the general memory pool and the constant string pool. Create
and initialize both pool structures, and allocate initial blocks of memory
for both.
@@ -712,7 +712,7 @@
/*
-=item C<void merge_pools(Memory_Pool *dest, Memory_Pool *source)>
+=item C<void merge_pools(Var_Size_Obj_Pool *dest, Var_Size_Obj_Pool *source)>
Merge two memory pools together. Do this by moving all memory blocks
from the C<*source> pool into the C<*dest> pool. The C<source> pool
@@ -723,7 +723,7 @@
*/
void
-merge_pools(ARGMOD(Memory_Pool *dest), ARGMOD(Memory_Pool *source))
+merge_pools(ARGMOD(Var_Size_Obj_Pool *dest), ARGMOD(Var_Size_Obj_Pool *source))
{
ASSERT_ARGS(merge_pools)
Memory_Block *cur_block;
@@ -772,23 +772,23 @@
size_t i;
Arenas * const arena_base = interp->arena_base;
- check_memory_pool(arena_base->memory_pool);
- check_memory_pool(arena_base->constant_string_pool);
- check_small_object_pool(arena_base->pmc_pool);
- check_small_object_pool(arena_base->constant_pmc_pool);
- check_small_object_pool(arena_base->string_header_pool);
- check_small_object_pool(arena_base->constant_string_header_pool);
+ check_var_size_obj_pool(arena_base->memory_pool);
+ check_var_size_obj_pool(arena_base->constant_string_pool);
+ check_fixed_size_obj_pool(arena_base->pmc_pool);
+ check_fixed_size_obj_pool(arena_base->constant_pmc_pool);
+ check_fixed_size_obj_pool(arena_base->string_header_pool);
+ check_fixed_size_obj_pool(arena_base->constant_string_header_pool);
for (i = 0; i < arena_base->num_sized; i++) {
- Small_Object_Pool * pool = arena_base->sized_header_pools[i];
+ Fixed_Size_Obj_Pool * pool = arena_base->sized_header_pools[i];
if (pool != NULL && pool != arena_base->string_header_pool)
- check_small_object_pool(pool);
+ check_fixed_size_obj_pool(pool);
}
}
/*
-=item C<static void check_small_object_pool(Small_Object_Pool * pool)>
+=item C<static void check_fixed_size_obj_pool(Fixed_Size_Obj_Pool * pool)>
Checks a small object pool, if it contains buffer it checks the buffers also.
@@ -797,12 +797,12 @@
*/
static void
-check_small_object_pool(ARGMOD(Small_Object_Pool * pool))
+check_fixed_size_obj_pool(ARGMOD(Fixed_Size_Obj_Pool * pool))
{
- ASSERT_ARGS(check_small_object_pool)
+ ASSERT_ARGS(check_fixed_size_obj_pool)
size_t total_objects;
size_t last_free_list_count;
- Small_Object_Arena * arena_walker;
+ Fixed_Size_Obj_Arena * arena_walker;
size_t free_objects;
PObj * object;
size_t i;
@@ -867,7 +867,7 @@
/*
-=item C<static void check_memory_pool(Memory_Pool *pool)>
+=item C<static void check_var_size_obj_pool(Var_Size_Obj_Pool *pool)>
Checks a memory pool, containing buffer data
@@ -876,9 +876,9 @@
*/
static void
-check_memory_pool(ARGMOD(Memory_Pool *pool))
+check_var_size_obj_pool(ARGMOD(Var_Size_Obj_Pool *pool))
{
- ASSERT_ARGS(check_memory_pool)
+ ASSERT_ARGS(check_var_size_obj_pool)
size_t count;
Memory_Block * block_walker;
count = 10000000; /*detect unendless loop just use big enough number*/
@@ -900,7 +900,7 @@
/*
-=item C<void check_buffer_ptr(Buffer * pobj, Memory_Pool * pool)>
+=item C<void check_buffer_ptr(Buffer * pobj, Var_Size_Obj_Pool * pool)>
Checks wether the buffer is within the bounds of the memory pool
@@ -909,7 +909,7 @@
*/
void
-check_buffer_ptr(ARGMOD(Buffer * pobj), ARGMOD(Memory_Pool * pool))
+check_buffer_ptr(ARGMOD(Buffer * pobj), ARGMOD(Var_Size_Obj_Pool * pool))
{
ASSERT_ARGS(check_buffer_ptr)
Memory_Block * cur_block = pool->top_block;
Modified: branches/gc-refactor/src/gc/api.c
==============================================================================
--- branches/gc-refactor/src/gc/api.c Sat Sep 5 19:45:25 2009 (r41014)
+++ branches/gc-refactor/src/gc/api.c Sat Sep 5 20:20:31 2009 (r41015)
@@ -45,7 +45,7 @@
=item F<src/gc/alloc_resources.c>
This file implements handling logic for strings and arbitrary-sized memory
-buffers. String storage is managed by special Memory_Pool structures, and use
+buffers. String storage is managed by special Var_Size_Obj_Pool structures, and use
a separate compacting garbage collector to keep track of them.
=item F<src/gc/incremental_ms.c>
@@ -101,29 +101,29 @@
/* HEADERIZER BEGIN: static */
/* Don't modify between HEADERIZER BEGIN / HEADERIZER END. Your changes will be lost. */
-static void cleanup_next_for_GC_pool(ARGIN(Small_Object_Pool *pool))
+static void cleanup_next_for_GC_pool(ARGIN(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1);
static void fix_pmc_syncs(
ARGMOD(Interp *dest_interp),
- ARGIN(Small_Object_Pool *pool))
+ ARGIN(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*dest_interp);
-static void free_pool(ARGMOD(Small_Object_Pool *pool))
+static void free_pool(ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
FUNC_MODIFIES(*pool);
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-static void * get_free_buffer(PARROT_INTERP, ARGIN(Small_Object_Pool *pool))
+static void * get_free_buffer(PARROT_INTERP, ARGIN(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2);
static void Parrot_gc_merge_buffer_pools(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *dest),
- ARGMOD(Small_Object_Pool *source))
+ ARGMOD(Fixed_Size_Obj_Pool *dest),
+ ARGMOD(Fixed_Size_Obj_Pool *source))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
__attribute__nonnull__(3)
@@ -131,7 +131,7 @@
FUNC_MODIFIES(*source);
static int sweep_cb_buf(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
SHIM(int flag),
ARGIN(void *arg))
__attribute__nonnull__(1)
@@ -140,7 +140,7 @@
FUNC_MODIFIES(*pool);
static int sweep_cb_pmc(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
SHIM(int flag),
SHIM(void *arg))
__attribute__nonnull__(1)
@@ -348,7 +348,7 @@
Parrot_gc_new_pmc_header(PARROT_INTERP, UINTVAL flags)
{
ASSERT_ARGS(Parrot_gc_new_pmc_header)
- Small_Object_Pool * const pool = flags & PObj_constant_FLAG
+ Fixed_Size_Obj_Pool * const pool = flags & PObj_constant_FLAG
? interp->arena_base->constant_pmc_pool
: interp->arena_base->pmc_pool;
PMC * const pmc = (PMC *)pool->get_free_object(interp, pool);
@@ -383,7 +383,7 @@
Parrot_gc_free_pmc_header(PARROT_INTERP, ARGMOD(PMC *pmc))
{
ASSERT_ARGS(Parrot_gc_free_pmc_header)
- Small_Object_Pool * const pool = (PObj_constant_TEST(pmc)) ?
+ Fixed_Size_Obj_Pool * const pool = (PObj_constant_TEST(pmc)) ?
interp->arena_base->constant_pmc_pool : interp->arena_base->pmc_pool;
Parrot_pmc_destroy(interp, pmc);
@@ -496,7 +496,7 @@
{
ASSERT_ARGS(Parrot_gc_free_string_header)
if (!PObj_constant_TEST(s)) {
- Small_Object_Pool * const pool = interp->arena_base->string_header_pool;
+ Fixed_Size_Obj_Pool * const pool = interp->arena_base->string_header_pool;
pool->add_free_object(interp, pool, s);
}
}
@@ -521,14 +521,14 @@
{
ASSERT_ARGS(Parrot_gc_new_bufferlike_header)
- Small_Object_Pool * const pool = get_bufferlike_pool(interp, size);
+ Fixed_Size_Obj_Pool * const pool = get_bufferlike_pool(interp, size);
return get_free_buffer(interp, pool);
}
/*
-=item C<static void * get_free_buffer(PARROT_INTERP, Small_Object_Pool *pool)>
+=item C<static void * get_free_buffer(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
Gets a free object or buffer from the given C<pool> and returns it. If the
object is larger then a standard C<PObj> structure, all additional memory is
@@ -541,7 +541,7 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
static void *
-get_free_buffer(PARROT_INTERP, ARGIN(Small_Object_Pool *pool))
+get_free_buffer(PARROT_INTERP, ARGIN(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(get_free_buffer)
Buffer * const buffer = (Buffer *)pool->get_free_object(interp, pool);
@@ -574,7 +574,7 @@
size_t size)
{
ASSERT_ARGS(Parrot_gc_free_bufferlike_header)
- Small_Object_Pool * const pool = get_bufferlike_pool(interp, size);
+ Fixed_Size_Obj_Pool * const pool = get_bufferlike_pool(interp, size);
pool->add_free_object(interp, pool, obj);
}
@@ -633,7 +633,7 @@
ASSERT_ARGS(Parrot_gc_reallocate_buffer_storage)
size_t copysize;
char *mem;
- Memory_Pool * const pool = interp->arena_base->memory_pool;
+ Var_Size_Obj_Pool * const pool = interp->arena_base->memory_pool;
size_t new_size, needed, old_size;
/*
@@ -704,7 +704,7 @@
{
ASSERT_ARGS(Parrot_gc_allocate_string_storage)
size_t new_size;
- Memory_Pool *pool;
+ Var_Size_Obj_Pool *pool;
char *mem;
Buffer_buflen(str) = 0;
@@ -751,7 +751,7 @@
char *mem, *oldmem;
size_t new_size, needed, old_size;
- Memory_Pool * const pool =
+ Var_Size_Obj_Pool * const pool =
PObj_constant_TEST(str)
? interp->arena_base->constant_string_pool
: interp->arena_base->memory_pool;
@@ -880,7 +880,7 @@
if (i >= dest_arena->num_sized
|| !dest_arena->sized_header_pools[i]) {
- Small_Object_Pool *ignored = get_bufferlike_pool(dest_interp,
+ Fixed_Size_Obj_Pool *ignored = get_bufferlike_pool(dest_interp,
i * sizeof (void *));
UNUSED(ignored);
PARROT_ASSERT(dest_arena->sized_header_pools[i]);
@@ -895,7 +895,7 @@
/*
=item C<static void Parrot_gc_merge_buffer_pools(PARROT_INTERP,
-Small_Object_Pool *dest, Small_Object_Pool *source)>
+Fixed_Size_Obj_Pool *dest, Fixed_Size_Obj_Pool *source)>
Merge pool C<source> into pool C<dest>. Combines the free lists directly,
moves all arenas to the new pool, and remove the old pool. To merge, the
@@ -908,10 +908,10 @@
static void
Parrot_gc_merge_buffer_pools(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *dest), ARGMOD(Small_Object_Pool *source))
+ ARGMOD(Fixed_Size_Obj_Pool *dest), ARGMOD(Fixed_Size_Obj_Pool *source))
{
ASSERT_ARGS(Parrot_gc_merge_buffer_pools)
- Small_Object_Arena *cur_arena;
+ Fixed_Size_Obj_Arena *cur_arena;
GC_MS_PObj_Wrapper *free_list_end;
PARROT_ASSERT(dest->object_size == source->object_size);
@@ -938,7 +938,7 @@
while (cur_arena) {
size_t total_objects;
- Small_Object_Arena * const next_arena = cur_arena->prev;
+ Fixed_Size_Obj_Arena * const next_arena = cur_arena->prev;
cur_arena->next = cur_arena->prev = NULL;
@@ -962,7 +962,7 @@
/*
-=item C<static void fix_pmc_syncs(Interp *dest_interp, Small_Object_Pool *pool)>
+=item C<static void fix_pmc_syncs(Interp *dest_interp, Fixed_Size_Obj_Pool *pool)>
Walks through the given arena, looking for all live and shared PMCs,
transferring their sync values to the destination interpreter.
@@ -972,10 +972,10 @@
*/
static void
-fix_pmc_syncs(ARGMOD(Interp *dest_interp), ARGIN(Small_Object_Pool *pool))
+fix_pmc_syncs(ARGMOD(Interp *dest_interp), ARGIN(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(fix_pmc_syncs)
- Small_Object_Arena *cur_arena;
+ Fixed_Size_Obj_Arena *cur_arena;
const UINTVAL object_size = pool->object_size;
for (cur_arena = pool->last_Arena; cur_arena; cur_arena = cur_arena->prev) {
@@ -1047,7 +1047,7 @@
/*
-=item C<static int sweep_cb_pmc(PARROT_INTERP, Small_Object_Pool *pool, int
+=item C<static int sweep_cb_pmc(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
flag, void *arg)>
Performs a garbage collection sweep of the given pmc pool, then frees it. Calls
@@ -1059,7 +1059,7 @@
*/
static int
-sweep_cb_pmc(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool),
+sweep_cb_pmc(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool),
SHIM(int flag), SHIM(void *arg))
{
Parrot_gc_sweep_pool(interp, pool);
@@ -1069,7 +1069,7 @@
/*
-=item C<static int sweep_cb_buf(PARROT_INTERP, Small_Object_Pool *pool, int
+=item C<static int sweep_cb_buf(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
flag, void *arg)>
Performs a final garbage collection sweep, then frees the pool. Calls
@@ -1081,7 +1081,7 @@
*/
static int
-sweep_cb_buf(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool), SHIM(int flag),
+sweep_cb_buf(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), SHIM(int flag),
ARGIN(void *arg))
{
#ifdef GC_IS_MALLOC
@@ -1105,7 +1105,7 @@
/*
-=item C<static void free_pool(Small_Object_Pool *pool)>
+=item C<static void free_pool(Fixed_Size_Obj_Pool *pool)>
Frees a pool and all of its arenas. Loops through the list of arenas backwards
and returns each to the memory manager. Then, frees the pool structure itself.
@@ -1115,13 +1115,13 @@
*/
static void
-free_pool(ARGMOD(Small_Object_Pool *pool))
+free_pool(ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(free_pool)
- Small_Object_Arena *cur_arena;
+ Fixed_Size_Obj_Arena *cur_arena;
for (cur_arena = pool->last_Arena; cur_arena;) {
- Small_Object_Arena * const next = cur_arena->prev;
+ Fixed_Size_Obj_Arena * const next = cur_arena->prev;
mem_internal_free(cur_arena->start_objects);
mem_internal_free(cur_arena);
cur_arena = next;
@@ -1149,7 +1149,7 @@
int i;
for (i = 0; i < 2; i++) {
- Memory_Pool * const pool = i ?
+ Var_Size_Obj_Pool * const pool = i ?
interp->arena_base->constant_string_pool :
interp->arena_base->memory_pool;
Memory_Block *cur_block;
@@ -1182,7 +1182,7 @@
Parrot_gc_ptr_in_memory_pool(PARROT_INTERP, ARGIN(void *bufstart))
{
ASSERT_ARGS(Parrot_gc_ptr_in_memory_pool)
- Memory_Pool * const pool = interp->arena_base->memory_pool;
+ Var_Size_Obj_Pool * const pool = interp->arena_base->memory_pool;
Memory_Block * cur_block = pool->top_block;
while (cur_block) {
@@ -1230,8 +1230,8 @@
{
ASSERT_ARGS(Parrot_gc_get_pmc_index)
UINTVAL id = 1; /* first PMC in first arena */
- Small_Object_Arena *arena;
- Small_Object_Pool *pool;
+ Fixed_Size_Obj_Arena *arena;
+ Fixed_Size_Obj_Pool *pool;
if (interp->gc_sys->PObj_to_Arena){
pmc = (PMC*) interp->gc_sys->PObj_to_Arena(pmc);
@@ -1284,7 +1284,7 @@
/*
-=item C<static void cleanup_next_for_GC_pool(Small_Object_Pool *pool)>
+=item C<static void cleanup_next_for_GC_pool(Fixed_Size_Obj_Pool *pool)>
Sets all the C<next_for_GC> pointers to C<NULL>.
@@ -1293,10 +1293,10 @@
*/
static void
-cleanup_next_for_GC_pool(ARGIN(Small_Object_Pool *pool))
+cleanup_next_for_GC_pool(ARGIN(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(cleanup_next_for_GC_pool)
- Small_Object_Arena *arena;
+ Fixed_Size_Obj_Arena *arena;
for (arena = pool->last_Arena; arena; arena = arena->prev) {
PMC *p = (PMC *)arena->start_objects;
@@ -1328,7 +1328,7 @@
int j, ret = 0;
const Arenas * const arena_base = interp->arena_base;
for (j = 0; j < (INTVAL)arena_base->num_sized; j++) {
- Small_Object_Pool * const header_pool =
+ Fixed_Size_Obj_Pool * const header_pool =
arena_base->sized_header_pools[j];
if (header_pool)
ret += header_pool->total_objects -
@@ -1354,7 +1354,7 @@
int j, ret = 0;
const Arenas * const arena_base = interp->arena_base;
for (j = 0; j < (INTVAL)arena_base->num_sized; j++) {
- Small_Object_Pool * const header_pool =
+ Fixed_Size_Obj_Pool * const header_pool =
arena_base->sized_header_pools[j];
if (header_pool)
ret += header_pool->total_objects;
Modified: branches/gc-refactor/src/gc/gc_inf.c
==============================================================================
--- branches/gc-refactor/src/gc/gc_inf.c Sat Sep 5 19:45:25 2009 (r41014)
+++ branches/gc-refactor/src/gc/gc_inf.c Sat Sep 5 20:20:31 2009 (r41015)
@@ -38,30 +38,30 @@
/* Don't modify between HEADERIZER BEGIN / HEADERIZER END. Your changes will be lost. */
static void gc_inf_add_free_object(SHIM_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
ARGIN(void *to_add))
__attribute__nonnull__(2)
__attribute__nonnull__(3)
FUNC_MODIFIES(*pool);
static void gc_inf_alloc_objects(SHIM_INTERP,
- ARGMOD(Small_Object_Pool *pool))
+ ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
PARROT_CANNOT_RETURN_NULL
static void * gc_inf_get_free_object(SHIM_INTERP,
- ARGMOD(Small_Object_Pool *pool))
+ ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
static void gc_inf_mark_and_sweep(SHIM_INTERP, UINTVAL flags);
static void gc_inf_more_traceable_objects(SHIM_INTERP,
- ARGMOD(Small_Object_Pool *pool))
+ ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
-static void gc_inf_pool_init(SHIM_INTERP, ARGMOD(Small_Object_Pool *pool))
+static void gc_inf_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
@@ -112,7 +112,7 @@
/*
-=item C<static void gc_inf_add_free_object(PARROT_INTERP, Small_Object_Pool
+=item C<static void gc_inf_add_free_object(PARROT_INTERP, Fixed_Size_Obj_Pool
*pool, void *to_add)>
Manually frees a chunk of memory. Normally this would return the memory
@@ -128,7 +128,7 @@
*/
static void
-gc_inf_add_free_object(SHIM_INTERP, ARGMOD(Small_Object_Pool *pool),
+gc_inf_add_free_object(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool),
ARGIN(void *to_add))
{
ASSERT_ARGS(gc_inf_add_free_object)
@@ -138,7 +138,7 @@
/*
-=item C<static void * gc_inf_get_free_object(PARROT_INTERP, Small_Object_Pool
+=item C<static void * gc_inf_get_free_object(PARROT_INTERP, Fixed_Size_Obj_Pool
*pool)>
Gets a new object from the pool. Each pool specifies an object size in
@@ -161,7 +161,7 @@
PARROT_CANNOT_RETURN_NULL
static void *
-gc_inf_get_free_object(SHIM_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_inf_get_free_object(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_inf_get_free_object)
return calloc(pool->object_size, 1);
@@ -169,7 +169,7 @@
/*
-=item C<static void gc_inf_alloc_objects(PARROT_INTERP, Small_Object_Pool
+=item C<static void gc_inf_alloc_objects(PARROT_INTERP, Fixed_Size_Obj_Pool
*pool)>
Allocates a new arena of objects from the system. This function is only
@@ -184,7 +184,7 @@
*/
static void
-gc_inf_alloc_objects(SHIM_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_inf_alloc_objects(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_inf_alloc_objects)
UNUSED(pool);
@@ -193,7 +193,7 @@
/*
=item C<static void gc_inf_more_traceable_objects(PARROT_INTERP,
-Small_Object_Pool *pool)>
+Fixed_Size_Obj_Pool *pool)>
Would normally try to find new traceable objects by first running a GC sweep
and then allocating a new arena from the system. Neither of these are
@@ -208,7 +208,7 @@
*/
static void
-gc_inf_more_traceable_objects(SHIM_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_inf_more_traceable_objects(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_inf_more_traceable_objects)
UNUSED(pool);
@@ -216,7 +216,7 @@
/*
-=item C<static void gc_inf_pool_init(PARROT_INTERP, Small_Object_Pool *pool)>
+=item C<static void gc_inf_pool_init(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
Initializes the function pointers in a new pool. When a new pool is created
we assign several function pointers to it for managing memory in the pool.
@@ -231,7 +231,7 @@
*/
static void
-gc_inf_pool_init(SHIM_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_inf_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_inf_pool_init)
pool->add_free_object = gc_inf_add_free_object;
Modified: branches/gc-refactor/src/gc/gc_malloc.c
==============================================================================
--- branches/gc-refactor/src/gc/gc_malloc.c Sat Sep 5 19:45:25 2009 (r41014)
+++ branches/gc-refactor/src/gc/gc_malloc.c Sat Sep 5 20:20:31 2009 (r41015)
@@ -28,14 +28,14 @@
/* Don't modify between HEADERIZER BEGIN / HEADERIZER END. Your changes will be lost. */
static void clear_cow(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
int cleanup)
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
static int sweep_cb(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
int flag,
ARGMOD(void *arg))
__attribute__nonnull__(1)
@@ -45,7 +45,7 @@
FUNC_MODIFIES(*arg);
static void used_cow(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
int cleanup)
__attribute__nonnull__(1)
__attribute__nonnull__(2)
@@ -58,7 +58,7 @@
/*
-=item C<static int sweep_cb(PARROT_INTERP, Small_Object_Pool *pool, int flag, void *arg)>
+=item C<static int sweep_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int flag, void *arg)>
Sweeps the given pool for the MS collector. This function also ends
the profiling timer, if profiling is enabled. Returns the total number
@@ -69,7 +69,7 @@
*/
static int
-sweep_cb(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool), int flag,
+sweep_cb(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), int flag,
ARGMOD(void *arg))
{
int * const total_free = (int *) arg;
@@ -93,7 +93,7 @@
/*
-=item C<static void clear_cow(PARROT_INTERP, Small_Object_Pool *pool, int cleanup)>
+=item C<static void clear_cow(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int cleanup)>
Clears the COW ref count.
@@ -102,10 +102,10 @@
*/
static void
-clear_cow(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool), int cleanup)
+clear_cow(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), int cleanup)
{
const UINTVAL object_size = pool->object_size;
- Small_Object_Arena *cur_arena;
+ Fixed_Size_Obj_Arena *cur_arena;
/* clear refcount for COWable objects. */
for (cur_arena = pool->last_Arena;
@@ -139,7 +139,7 @@
/*
-=item C<static void used_cow(PARROT_INTERP, Small_Object_Pool *pool, int cleanup)>
+=item C<static void used_cow(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int cleanup)>
Finds other users of COW's C<bufstart>.
@@ -148,10 +148,10 @@
*/
static void
-used_cow(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool), int cleanup)
+used_cow(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), int cleanup)
{
const UINTVAL object_size = pool->object_size;
- Small_Object_Arena *cur_arena;
+ Fixed_Size_Obj_Arena *cur_arena;
for (cur_arena = pool->last_Arena;
NULL != cur_arena; cur_arena = cur_arena->prev) {
Modified: branches/gc-refactor/src/gc/gc_ms.c
==============================================================================
--- branches/gc-refactor/src/gc/gc_ms.c Sat Sep 5 19:45:25 2009 (r41014)
+++ branches/gc-refactor/src/gc/gc_ms.c Sat Sep 5 20:20:31 2009 (r41015)
@@ -23,14 +23,14 @@
/* Don't modify between HEADERIZER BEGIN / HEADERIZER END. Your changes will be lost. */
static void gc_ms_add_free_object(SHIM_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
ARGIN(void *to_add))
__attribute__nonnull__(2)
__attribute__nonnull__(3)
FUNC_MODIFIES(*pool);
static void gc_ms_alloc_objects(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool))
+ ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
@@ -42,7 +42,7 @@
PARROT_CANNOT_RETURN_NULL
PARROT_WARN_UNUSED_RESULT
static void * gc_ms_get_free_object(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool))
+ ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
@@ -51,17 +51,17 @@
__attribute__nonnull__(1);
static void gc_ms_more_traceable_objects(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool))
+ ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
-static void gc_ms_pool_init(SHIM_INTERP, ARGMOD(Small_Object_Pool *pool))
+static void gc_ms_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
static int gc_ms_sweep_cb(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
int flag,
ARGMOD(void *arg))
__attribute__nonnull__(1)
@@ -263,7 +263,7 @@
/*
-=item C<static int gc_ms_sweep_cb(PARROT_INTERP, Small_Object_Pool *pool, int
+=item C<static int gc_ms_sweep_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
flag, void *arg)>
Sweeps the given pool for the MS collector. This function also ends
@@ -275,7 +275,7 @@
*/
static int
-gc_ms_sweep_cb(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool), int flag,
+gc_ms_sweep_cb(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), int flag,
ARGMOD(void *arg))
{
ASSERT_ARGS(gc_ms_sweep_cb)
@@ -299,7 +299,7 @@
=over 4
-=item C<static void gc_ms_pool_init(PARROT_INTERP, Small_Object_Pool *pool)>
+=item C<static void gc_ms_pool_init(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
Initialize a memory pool for the MS garbage collector system. Sets the
function pointers necessary to perform basic operations on a pool, such
@@ -310,7 +310,7 @@
*/
static void
-gc_ms_pool_init(SHIM_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_ms_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_ms_pool_init)
pool->add_free_object = gc_ms_add_free_object;
@@ -322,7 +322,7 @@
/*
=item C<static void gc_ms_more_traceable_objects(PARROT_INTERP,
-Small_Object_Pool *pool)>
+Fixed_Size_Obj_Pool *pool)>
We're out of traceable objects. First we try a GC run to free some up. If
that doesn't work, allocate a new arena.
@@ -332,14 +332,14 @@
*/
static void
-gc_ms_more_traceable_objects(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_ms_more_traceable_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_ms_more_traceable_objects)
if (pool->skip)
pool->skip = 0;
else {
- Small_Object_Arena * const arena = pool->last_Arena;
+ Fixed_Size_Obj_Arena * const arena = pool->last_Arena;
if (arena
&& arena->used == arena->total_objects)
Parrot_gc_mark_and_sweep(interp, GC_trace_stack_FLAG);
@@ -359,7 +359,7 @@
/*
-=item C<static void gc_ms_add_free_object(PARROT_INTERP, Small_Object_Pool
+=item C<static void gc_ms_add_free_object(PARROT_INTERP, Fixed_Size_Obj_Pool
*pool, void *to_add)>
Add an unused object back to the pool's free list for later reuse. Set
@@ -370,7 +370,7 @@
*/
static void
-gc_ms_add_free_object(SHIM_INTERP, ARGMOD(Small_Object_Pool *pool),
+gc_ms_add_free_object(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool),
ARGIN(void *to_add))
{
ASSERT_ARGS(gc_ms_add_free_object)
@@ -384,7 +384,7 @@
/*
-=item C<static void * gc_ms_get_free_object(PARROT_INTERP, Small_Object_Pool
+=item C<static void * gc_ms_get_free_object(PARROT_INTERP, Fixed_Size_Obj_Pool
*pool)>
Free object allocator for the MS garbage collector system. If there are no
@@ -399,7 +399,7 @@
PARROT_CANNOT_RETURN_NULL
PARROT_WARN_UNUSED_RESULT
static void *
-gc_ms_get_free_object(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_ms_get_free_object(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_ms_get_free_object)
PObj *ptr;
@@ -412,7 +412,7 @@
}
if (!free_list) {
- Small_Object_Arena * const arena = pool->last_Arena;
+ Fixed_Size_Obj_Arena * const arena = pool->last_Arena;
ptr = (PObj *)pool->newfree;
pool->newfree = (void *)((char *)pool->newfree + pool->object_size);
arena->used++;
@@ -448,7 +448,7 @@
/*
-=item C<static void gc_ms_alloc_objects(PARROT_INTERP, Small_Object_Pool *pool)>
+=item C<static void gc_ms_alloc_objects(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
New arena allocator function for the MS garbage collector system. Allocates
and initializes a new memory arena in the given pool. Adds all the new
@@ -459,13 +459,13 @@
*/
static void
-gc_ms_alloc_objects(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_ms_alloc_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_ms_alloc_objects)
/* Setup memory for the new objects */
- Small_Object_Arena * const new_arena =
- mem_internal_allocate_typed(Small_Object_Arena);
+ Fixed_Size_Obj_Arena * const new_arena =
+ mem_internal_allocate_typed(Fixed_Size_Obj_Arena);
const size_t size = pool->object_size * pool->objects_per_alloc;
size_t alloc_size;
Modified: branches/gc-refactor/src/gc/gc_private.h
==============================================================================
--- branches/gc-refactor/src/gc/gc_private.h Sat Sep 5 19:45:25 2009 (r41014)
+++ branches/gc-refactor/src/gc/gc_private.h Sat Sep 5 20:20:31 2009 (r41015)
@@ -114,13 +114,13 @@
size_t header_size;
} GC_Subsystem;
-typedef struct Small_Object_Arena {
+typedef struct Fixed_Size_Obj_Arena {
size_t used;
size_t total_objects;
- struct Small_Object_Arena *prev;
- struct Small_Object_Arena *next;
+ struct Fixed_Size_Obj_Arena *prev;
+ struct Fixed_Size_Obj_Arena *next;
void *start_objects;
-} Small_Object_Arena;
+} Fixed_Size_Obj_Arena;
typedef struct PMC_Attribute_Free_List {
struct PMC_Attribute_Free_List * next;
@@ -145,8 +145,8 @@
} PMC_Attribute_Pool;
/* Tracked resource pool */
-typedef struct Small_Object_Pool {
- Small_Object_Arena *last_Arena;
+typedef struct Fixed_Size_Obj_Pool {
+ Fixed_Size_Obj_Arena *last_Arena;
/* Size in bytes of an individual pool item. This size may include
* a GC-system specific GC header.
* See the macros below.
@@ -171,7 +171,7 @@
- struct Memory_Pool *mem_pool;
+ struct Var_Size_Obj_Pool *mem_pool;
size_t start_arena_memory;
size_t end_arena_memory;
PARROT_OBSERVER const char *name;
@@ -186,16 +186,16 @@
void *newlast;
#endif
-} Small_Object_Pool;
+} Fixed_Size_Obj_Pool;
typedef struct Arenas {
- Memory_Pool *memory_pool;
- Memory_Pool *constant_string_pool;
- struct Small_Object_Pool *string_header_pool;
- struct Small_Object_Pool *pmc_pool;
- struct Small_Object_Pool *constant_pmc_pool;
- struct Small_Object_Pool *constant_string_header_pool;
- struct Small_Object_Pool **sized_header_pools;
+ Var_Size_Obj_Pool *memory_pool;
+ Var_Size_Obj_Pool *constant_string_pool;
+ struct Fixed_Size_Obj_Pool *string_header_pool;
+ struct Fixed_Size_Obj_Pool *pmc_pool;
+ struct Fixed_Size_Obj_Pool *constant_pmc_pool;
+ struct Fixed_Size_Obj_Pool *constant_string_header_pool;
+ struct Fixed_Size_Obj_Pool **sized_header_pools;
size_t num_sized;
PMC_Attribute_Pool **attrib_pools;
@@ -206,7 +206,7 @@
*/
void (*do_gc_mark)(PARROT_INTERP, UINTVAL flags);
void (*finalize_gc_system) (PARROT_INTERP);
- void (*init_pool)(PARROT_INTERP, struct Small_Object_Pool *);
+ void (*init_pool)(PARROT_INTERP, struct Fixed_Size_Obj_Pool *);
/*
* statistics for GC
*/
@@ -346,7 +346,7 @@
PARROT_WARN_UNUSED_RESULT
INTVAL contained_in_pool(PARROT_INTERP,
- ARGIN(const Small_Object_Pool *pool),
+ ARGIN(const Fixed_Size_Obj_Pool *pool),
ARGIN(const void *ptr))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
@@ -354,7 +354,7 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-Small_Object_Pool * get_bufferlike_pool(PARROT_INTERP, size_t buffer_size)
+Fixed_Size_Obj_Pool * get_bufferlike_pool(PARROT_INTERP, size_t buffer_size)
__attribute__nonnull__(1);
PARROT_IGNORABLE_RESULT
@@ -374,8 +374,8 @@
__attribute__nonnull__(2);
void Parrot_add_to_free_list(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
- ARGMOD(Small_Object_Arena *arena))
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Arena *arena))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
__attribute__nonnull__(3)
@@ -383,8 +383,8 @@
FUNC_MODIFIES(*arena);
void Parrot_append_arena_in_pool(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
- ARGMOD(Small_Object_Arena *new_arena),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Arena *new_arena),
size_t size)
__attribute__nonnull__(1)
__attribute__nonnull__(2)
@@ -393,7 +393,7 @@
FUNC_MODIFIES(*new_arena);
void Parrot_gc_clear_live_bits(PARROT_INTERP,
- ARGIN(const Small_Object_Pool *pool))
+ ARGIN(const Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2);
@@ -427,7 +427,7 @@
void Parrot_gc_run_init(PARROT_INTERP)
__attribute__nonnull__(1);
-void Parrot_gc_sweep_pool(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool))
+void Parrot_gc_sweep_pool(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
@@ -495,7 +495,7 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-Small_Object_Pool * get_bufferlike_pool(PARROT_INTERP, size_t buffer_size)
+Fixed_Size_Obj_Pool * get_bufferlike_pool(PARROT_INTERP, size_t buffer_size)
__attribute__nonnull__(1);
PARROT_IGNORABLE_RESULT
@@ -538,13 +538,13 @@
PARROT_WARN_UNUSED_RESULT
size_t aligned_string_size(size_t len);
-void check_buffer_ptr(ARGMOD(Buffer * pobj), ARGMOD(Memory_Pool * pool))
+void check_buffer_ptr(ARGMOD(Buffer * pobj), ARGMOD(Var_Size_Obj_Pool * pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(* pobj)
FUNC_MODIFIES(* pool);
-void compact_pool(PARROT_INTERP, ARGMOD(Memory_Pool *pool))
+void compact_pool(PARROT_INTERP, ARGMOD(Var_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
@@ -554,12 +554,12 @@
PARROT_MALLOC
PARROT_CANNOT_RETURN_NULL
-void * mem_allocate(PARROT_INTERP, size_t size, ARGMOD(Memory_Pool *pool))
+void * mem_allocate(PARROT_INTERP, size_t size, ARGMOD(Var_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(3)
FUNC_MODIFIES(*pool);
-void merge_pools(ARGMOD(Memory_Pool *dest), ARGMOD(Memory_Pool *source))
+void merge_pools(ARGMOD(Var_Size_Obj_Pool *dest), ARGMOD(Var_Size_Obj_Pool *source))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*dest)
Modified: branches/gc-refactor/src/gc/generational_ms.c
==============================================================================
--- branches/gc-refactor/src/gc/generational_ms.c Sat Sep 5 19:45:25 2009 (r41014)
+++ branches/gc-refactor/src/gc/generational_ms.c Sat Sep 5 20:20:31 2009 (r41015)
@@ -125,7 +125,7 @@
/* Don't modify between HEADERIZER BEGIN / HEADERIZER END. Your changes will be lost. */
static int end_cycle_cb(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
int flag,
SHIM(void *arg))
__attribute__nonnull__(1)
@@ -133,19 +133,19 @@
FUNC_MODIFIES(*pool);
static void gc_gms_add_free_object(PARROT_INTERP,
- SHIM(Small_Object_Pool *pool),
+ SHIM(Fixed_Size_Obj_Pool *pool),
SHIM(PObj *to_add))
__attribute__nonnull__(1);
static void gc_gms_alloc_objects(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool))
+ ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
static void gc_gms_chain_objects(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
- ARGIN(Small_Object_Arena *new_arena),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGIN(Fixed_Size_Obj_Arena *new_arena),
size_t real_size)
__attribute__nonnull__(1)
__attribute__nonnull__(2)
@@ -164,7 +164,7 @@
PARROT_MALLOC
PARROT_CANNOT_RETURN_NULL
static Gc_gms_gen * gc_gms_create_gen(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
size_t gen_no)
__attribute__nonnull__(1)
__attribute__nonnull__(2)
@@ -184,12 +184,12 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
static PObj * gc_gms_get_free_object(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool))
+ ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
-static void gc_gms_init_gen(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool))
+static void gc_gms_init_gen(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
@@ -198,7 +198,7 @@
__attribute__nonnull__(1);
static void gc_gms_merge_gen(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
int flag,
SHIM(Gc_gms_plan *plan))
__attribute__nonnull__(1)
@@ -206,12 +206,12 @@
FUNC_MODIFIES(*pool);
static void gc_gms_more_objects(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool))
+ ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
-static void gc_gms_pool_init(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool))
+static void gc_gms_pool_init(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
@@ -260,7 +260,7 @@
__attribute__nonnull__(1);
static void gc_gms_use_gen(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
int flag,
ARGIN(const Gc_gms_plan *plan))
__attribute__nonnull__(1)
@@ -269,7 +269,7 @@
FUNC_MODIFIES(*pool);
static void gms_debug_verify(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
ARGIN(const char *action))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
@@ -277,7 +277,7 @@
FUNC_MODIFIES(*pool);
static int init_mark_cb(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
int flag,
ARGIN(void *arg))
__attribute__nonnull__(1)
@@ -293,7 +293,7 @@
PARROT_WARN_UNUSED_RESULT
static int set_gen_cb(PARROT_INTERP,
- ARGIN(Small_Object_Pool *pool),
+ ARGIN(Fixed_Size_Obj_Pool *pool),
int flag,
ARGIN(void *arg))
__attribute__nonnull__(1)
@@ -301,7 +301,7 @@
__attribute__nonnull__(4);
static int sweep_cb_buf(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
int flag,
SHIM(void *arg))
__attribute__nonnull__(1)
@@ -309,21 +309,21 @@
FUNC_MODIFIES(*pool);
static int sweep_cb_pmc(PARROT_INTERP,
- ARGIN(Small_Object_Pool *pool),
+ ARGIN(Fixed_Size_Obj_Pool *pool),
int flag,
SHIM(void *arg))
__attribute__nonnull__(1)
__attribute__nonnull__(2);
static int trace_children_cb(PARROT_INTERP,
- ARGIN(Small_Object_Pool *pool),
+ ARGIN(Fixed_Size_Obj_Pool *pool),
int flag,
SHIM(void *arg))
__attribute__nonnull__(1)
__attribute__nonnull__(2);
static int trace_igp_cb(PARROT_INTERP,
- ARGIN(Small_Object_Pool *pool),
+ ARGIN(Fixed_Size_Obj_Pool *pool),
int flag,
SHIM(void *arg))
__attribute__nonnull__(1)
@@ -520,7 +520,7 @@
/*
-=item C<static void gc_gms_pool_init(PARROT_INTERP, Small_Object_Pool *pool)>
+=item C<static void gc_gms_pool_init(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
Initialize pool variables. This function must set the pool function pointers
for C<add_free_object>, C<get_free_object>, C<alloc_objects>, and
@@ -531,7 +531,7 @@
*/
static void
-gc_gms_pool_init(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_gms_pool_init(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_gms_pool_init)
pool->add_free_object = gc_gms_add_free_object;
@@ -583,7 +583,7 @@
=over 4
-=item C<static void gc_gms_add_free_object(PARROT_INTERP, Small_Object_Pool
+=item C<static void gc_gms_add_free_object(PARROT_INTERP, Fixed_Size_Obj_Pool
*pool, PObj *to_add)>
Unused. White (dead) objects are added in a bunch to the free_list.
@@ -593,7 +593,7 @@
*/
static void
-gc_gms_add_free_object(PARROT_INTERP, SHIM(Small_Object_Pool *pool),
+gc_gms_add_free_object(PARROT_INTERP, SHIM(Fixed_Size_Obj_Pool *pool),
SHIM(PObj *to_add))
{
ASSERT_ARGS(gc_gms_add_free_object)
@@ -603,8 +603,8 @@
/*
-=item C<static void gc_gms_chain_objects(PARROT_INTERP, Small_Object_Pool *pool,
-Small_Object_Arena *new_arena, size_t real_size)>
+=item C<static void gc_gms_chain_objects(PARROT_INTERP, Fixed_Size_Obj_Pool *pool,
+Fixed_Size_Obj_Arena *new_arena, size_t real_size)>
TODO: interfere custom_destroy and put these items into a
separate white area, so that a sweep has just to run through these
@@ -644,8 +644,8 @@
*/
static void
-gc_gms_chain_objects(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool),
- ARGIN(Small_Object_Arena *new_arena), size_t real_size)
+gc_gms_chain_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGIN(Fixed_Size_Obj_Arena *new_arena), size_t real_size)
{
ASSERT_ARGS(gc_gms_chain_objects)
Gc_gms_hdr *next, *prev;
@@ -694,7 +694,7 @@
/*
-=item C<static void gc_gms_alloc_objects(PARROT_INTERP, Small_Object_Pool
+=item C<static void gc_gms_alloc_objects(PARROT_INTERP, Fixed_Size_Obj_Pool
*pool)>
Allocate new objects for the given pool.
@@ -704,11 +704,11 @@
*/
static void
-gc_gms_alloc_objects(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_gms_alloc_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_gms_alloc_objects)
const size_t real_size = pool->object_size;
- Small_Object_Arena * const new_arena = mem_internal_allocate(sizeof (Small_Object_Arena));
+ Fixed_Size_Obj_Arena * const new_arena = mem_internal_allocate(sizeof (Fixed_Size_Obj_Arena));
const size_t size = real_size * pool->objects_per_alloc;
new_arena->start_objects = mem_internal_allocate(size);
@@ -728,7 +728,7 @@
/*
-=item C<static void gc_gms_more_objects(PARROT_INTERP, Small_Object_Pool *pool)>
+=item C<static void gc_gms_more_objects(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
Run a GC cycle or allocate new objects for the given pool.
@@ -737,7 +737,7 @@
*/
static void
-gc_gms_more_objects(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_gms_more_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_gms_more_objects)
if (pool->skip)
@@ -755,7 +755,7 @@
/*
-=item C<static PObj * gc_gms_get_free_object(PARROT_INTERP, Small_Object_Pool
+=item C<static PObj * gc_gms_get_free_object(PARROT_INTERP, Fixed_Size_Obj_Pool
*pool)>
Get a new object off the free_list in the given pool.
@@ -770,7 +770,7 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
static PObj *
-gc_gms_get_free_object(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_gms_get_free_object(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_gms_get_free_object)
PObj *ptr;
@@ -812,7 +812,7 @@
=over 4
-=item C<static Gc_gms_gen * gc_gms_create_gen(PARROT_INTERP, Small_Object_Pool
+=item C<static Gc_gms_gen * gc_gms_create_gen(PARROT_INTERP, Fixed_Size_Obj_Pool
*pool, size_t gen_no)>
Create a generation structure for the given generation number.
@@ -824,7 +824,7 @@
PARROT_MALLOC
PARROT_CANNOT_RETURN_NULL
static Gc_gms_gen *
-gc_gms_create_gen(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool), size_t gen_no)
+gc_gms_create_gen(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), size_t gen_no)
{
ASSERT_ARGS(gc_gms_create_gen)
Gc_gms_gen * const gen = mem_sys_allocate(sizeof (*gen));
@@ -844,7 +844,7 @@
/*
-=item C<static void gc_gms_init_gen(PARROT_INTERP, Small_Object_Pool *pool)>
+=item C<static void gc_gms_init_gen(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
Initalize the generation system by creating the first two generations.
@@ -853,7 +853,7 @@
*/
static void
-gc_gms_init_gen(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_gms_init_gen(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_gms_init_gen)
Gc_gms_private *gmsp;
@@ -890,7 +890,7 @@
{
ASSERT_ARGS(gc_gms_find_gen)
Gc_gms_gen *gen;
- const Small_Object_Pool * const pool = h->gen->pool;
+ const Fixed_Size_Obj_Pool * const pool = h->gen->pool;
PARROT_ASSERT(pool);
@@ -928,7 +928,7 @@
ASSERT_ARGS(gc_gms_promote)
Gc_gms_gen *gen;
Gc_gms_hdr *prev, *next;
- Small_Object_Pool * const pool = h->gen->pool;
+ Fixed_Size_Obj_Pool * const pool = h->gen->pool;
/* unsnap from current generation */
prev = h->prev;
@@ -1131,7 +1131,7 @@
/*
-=item C<static void gc_gms_merge_gen(PARROT_INTERP, Small_Object_Pool *pool, int
+=item C<static void gc_gms_merge_gen(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
flag, Gc_gms_plan *plan)>
Merge black pointers to the previous generation, and update the free list.
@@ -1141,7 +1141,7 @@
*/
static void
-gc_gms_merge_gen(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool),
+gc_gms_merge_gen(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool),
int flag, SHIM(Gc_gms_plan *plan))
{
ASSERT_ARGS(gc_gms_merge_gen)
@@ -1167,7 +1167,7 @@
/*
-=item C<static void gc_gms_use_gen(PARROT_INTERP, Small_Object_Pool *pool, int
+=item C<static void gc_gms_use_gen(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
flag, const Gc_gms_plan *plan)>
Specify what generation to use by default.
@@ -1177,7 +1177,7 @@
*/
static void
-gc_gms_use_gen(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool),
+gc_gms_use_gen(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool),
int flag, ARGIN(const Gc_gms_plan *plan))
{
ASSERT_ARGS(gc_gms_use_gen)
@@ -1204,7 +1204,7 @@
/*
-=item C<static int set_gen_cb(PARROT_INTERP, Small_Object_Pool *pool, int flag,
+=item C<static int set_gen_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int flag,
void *arg)>
Set the generation to use, merging if necessary.
@@ -1215,7 +1215,7 @@
PARROT_WARN_UNUSED_RESULT
static int
-set_gen_cb(PARROT_INTERP, ARGIN(Small_Object_Pool *pool), int flag, ARGIN(void *arg))
+set_gen_cb(PARROT_INTERP, ARGIN(Fixed_Size_Obj_Pool *pool), int flag, ARGIN(void *arg))
{
ASSERT_ARGS(set_gen_cb)
Gc_gms_plan * const plan = (Gc_gms_plan *)arg;
@@ -1360,7 +1360,7 @@
gc_gms_setto_gray(PARROT_INTERP, ARGIN(Gc_gms_hdr *h), int priority)
{
ASSERT_ARGS(gc_gms_setto_gray)
- Small_Object_Pool * const pool = h->gen->pool;
+ Fixed_Size_Obj_Pool * const pool = h->gen->pool;
/*
* TODO high_priority like in src/gc/api.c
*/
@@ -1424,7 +1424,7 @@
gc_gms_setto_black(PARROT_INTERP, ARGMOD(Gc_gms_hdr *h), int priority)
{
ASSERT_ARGS(gc_gms_setto_black)
- Small_Object_Pool * const pool = h->gen->pool;
+ Fixed_Size_Obj_Pool * const pool = h->gen->pool;
/*
* TODO high_priority like src/gc/api.c
@@ -1502,7 +1502,7 @@
/*
-=item C<static int init_mark_cb(PARROT_INTERP, Small_Object_Pool *pool, int
+=item C<static int init_mark_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
flag, void *arg)>
Initialization callback, initialize all the pointers.
@@ -1512,7 +1512,7 @@
*/
static int
-init_mark_cb(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool), int flag, ARGIN(void *arg))
+init_mark_cb(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), int flag, ARGIN(void *arg))
{
ASSERT_ARGS(init_mark_cb)
pool->gray = pool->black = pool->black_fin = pool->white;
@@ -1548,7 +1548,7 @@
/*
-=item C<static int trace_igp_cb(PARROT_INTERP, Small_Object_Pool *pool, int
+=item C<static int trace_igp_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
flag, void *arg)>
Trace through the IGP of the pool to find alive items that are pointing
@@ -1559,7 +1559,7 @@
*/
static int
-trace_igp_cb(PARROT_INTERP, ARGIN(Small_Object_Pool *pool), int flag, SHIM(void *arg))
+trace_igp_cb(PARROT_INTERP, ARGIN(Fixed_Size_Obj_Pool *pool), int flag, SHIM(void *arg))
{
ASSERT_ARGS(trace_igp_cb)
Gc_gms_hdr_store *s;
@@ -1600,7 +1600,7 @@
/*
-=item C<static int trace_children_cb(PARROT_INTERP, Small_Object_Pool *pool, int
+=item C<static int trace_children_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
flag, void *arg)>
Trace through child objects
@@ -1610,7 +1610,7 @@
*/
static int
-trace_children_cb(PARROT_INTERP, ARGIN(Small_Object_Pool *pool), int flag, SHIM(void *arg))
+trace_children_cb(PARROT_INTERP, ARGIN(Fixed_Size_Obj_Pool *pool), int flag, SHIM(void *arg))
{
ASSERT_ARGS(trace_children_cb)
Arenas * const arena_base = interp->arena_base;
@@ -1667,7 +1667,7 @@
/*
-=item C<static int sweep_cb_pmc(PARROT_INTERP, Small_Object_Pool *pool, int
+=item C<static int sweep_cb_pmc(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
flag, void *arg)>
move everything from white up to the free_list to the free_list
@@ -1679,7 +1679,7 @@
*/
static int
-sweep_cb_pmc(PARROT_INTERP, ARGIN(Small_Object_Pool *pool), int flag, SHIM(void *arg))
+sweep_cb_pmc(PARROT_INTERP, ARGIN(Fixed_Size_Obj_Pool *pool), int flag, SHIM(void *arg))
{
ASSERT_ARGS(sweep_cb_pmc)
Gc_gms_hdr *h;
@@ -1700,7 +1700,7 @@
/*
-=item C<static int sweep_cb_buf(PARROT_INTERP, Small_Object_Pool *pool, int
+=item C<static int sweep_cb_buf(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
flag, void *arg)>
Sweep the buffer pool, freeing things that are dead.
@@ -1710,7 +1710,7 @@
*/
static int
-sweep_cb_buf(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool), int flag, SHIM(void *arg))
+sweep_cb_buf(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), int flag, SHIM(void *arg))
{
ASSERT_ARGS(sweep_cb_buf)
Gc_gms_hdr *h;
@@ -1751,11 +1751,11 @@
*/
if (pool->mem_pool) {
if (!PObj_COW_TEST(obj)) {
- ((Memory_Pool *)
+ ((Var_Size_Obj_Pool *)
pool->mem_pool)->guaranteed_reclaimable +=
PObj_buflen(obj);
}
- ((Memory_Pool *)
+ ((Var_Size_Obj_Pool *)
pool->mem_pool)->possibly_reclaimable +=
PObj_buflen(obj);
}
@@ -1787,7 +1787,7 @@
/*
-=item C<static int end_cycle_cb(PARROT_INTERP, Small_Object_Pool *pool, int
+=item C<static int end_cycle_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
flag, void *arg)>
Reset the pointers in the pool at the end of the cycle.
@@ -1797,7 +1797,7 @@
*/
static int
-end_cycle_cb(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool), int flag, SHIM(void *arg))
+end_cycle_cb(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), int flag, SHIM(void *arg))
{
ASSERT_ARGS(end_cycle_cb)
Gc_gms_hdr *h;
@@ -1863,7 +1863,7 @@
++arena_base->gc_mark_block_level;
g_gms = arena_base->gc_private;
if (flags & GC_finish_FLAG) {
- Small_Object_Pool * const pool = arena_base->pmc_pool;
+ Fixed_Size_Obj_Pool * const pool = arena_base->pmc_pool;
pool->white = pool->marker.next;
/* XXX need to sweep over objects that have finalizers only */
@@ -1894,7 +1894,7 @@
/*
-=item C<static void gms_debug_verify(PARROT_INTERP, Small_Object_Pool *pool,
+=item C<static void gms_debug_verify(PARROT_INTERP, Fixed_Size_Obj_Pool *pool,
const char *action)>
Debug function, check that everything is right.
@@ -1905,7 +1905,7 @@
# if GC_GMS_DEBUG
static void
-gms_debug_verify(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool), ARGIN(const char *action))
+gms_debug_verify(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), ARGIN(const char *action))
{
ASSERT_ARGS(gms_debug_verify)
Gc_gms_hdr *h;
Modified: branches/gc-refactor/src/gc/generational_ms.h
==============================================================================
--- branches/gc-refactor/src/gc/generational_ms.h Sat Sep 5 19:45:25 2009 (r41014)
+++ branches/gc-refactor/src/gc/generational_ms.h Sat Sep 5 20:20:31 2009 (r41015)
@@ -45,7 +45,7 @@
struct _gc_gms_hdr *first; /* first header in this generation */
struct _gc_gms_hdr *last; /* last header in this generation */
struct _gc_gms_hdr *fin; /* need destruction/finalization */
- struct Small_Object_Pool *pool; /* where this generation belongs to */
+ struct Fixed_Size_Obj_Pool *pool; /* where this generation belongs to */
Gc_gms_hdr_list igp; /* IGPs for this generation */
UINTVAL n_possibly_dead; /* overwritten count */
UINTVAL n_objects; /* live objects count */
@@ -53,7 +53,7 @@
struct _gc_gms_gen *next;
} Gc_gms_gen;
-/* System-specific data for the Small_Object_Pool struct's gc_sys_private_data field. */
+/* System-specific data for the Fixed_Size_Obj_Pool struct's gc_sys_private_data field. */
struct gc_gms_smallobjpool_data {
Gc_gms_hdr marker; /* limit of list ... also the anchor of the "header chain"
-- see gc_gms_chain_objects() */
Modified: branches/gc-refactor/src/gc/incremental_ms.c
==============================================================================
--- branches/gc-refactor/src/gc/incremental_ms.c Sat Sep 5 19:45:25 2009 (r41014)
+++ branches/gc-refactor/src/gc/incremental_ms.c Sat Sep 5 20:20:31 2009 (r41015)
@@ -338,7 +338,7 @@
/* Don't modify between HEADERIZER BEGIN / HEADERIZER END. Your changes will be lost. */
static int collect_cb(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
SHIM(int flag),
ARGIN(void *arg))
__attribute__nonnull__(1)
@@ -347,7 +347,7 @@
FUNC_MODIFIES(*pool);
static void gc_ims_add_free_object(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
ARGOUT(void *to_add))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
@@ -356,7 +356,7 @@
FUNC_MODIFIES(*to_add);
static void gc_ims_alloc_objects(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool))
+ ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
@@ -364,12 +364,12 @@
PARROT_CANNOT_RETURN_NULL
PARROT_WARN_UNUSED_RESULT
static void * gc_ims_get_free_object(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool))
+ ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
-static void gc_ims_pool_init(SHIM_INTERP, ARGMOD(Small_Object_Pool *pool))
+static void gc_ims_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
@@ -395,7 +395,7 @@
__attribute__nonnull__(1);
static int sweep_cb(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
int flag,
ARGIN(void *arg))
__attribute__nonnull__(1)
@@ -504,7 +504,7 @@
/*
-=item C<static void gc_ims_add_free_object(PARROT_INTERP, Small_Object_Pool
+=item C<static void gc_ims_add_free_object(PARROT_INTERP, Fixed_Size_Obj_Pool
*pool, void *to_add)>
Add object C<to_add> to the free_list in the given pool.
@@ -515,7 +515,7 @@
*/
static void
-gc_ims_add_free_object(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool), ARGOUT(void *to_add))
+gc_ims_add_free_object(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), ARGOUT(void *to_add))
{
ASSERT_ARGS(gc_ims_add_free_object)
*(void **)to_add = pool->free_list;
@@ -532,7 +532,7 @@
/*
-=item C<static void * gc_ims_get_free_object(PARROT_INTERP, Small_Object_Pool
+=item C<static void * gc_ims_get_free_object(PARROT_INTERP, Fixed_Size_Obj_Pool
*pool)>
Get a new object off the free_list in the given pool.
@@ -544,7 +544,7 @@
PARROT_CANNOT_RETURN_NULL
PARROT_WARN_UNUSED_RESULT
static void *
-gc_ims_get_free_object(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_ims_get_free_object(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_ims_get_free_object)
PObj *ptr;
@@ -576,7 +576,7 @@
/*
-=item C<static void gc_ims_alloc_objects(PARROT_INTERP, Small_Object_Pool
+=item C<static void gc_ims_alloc_objects(PARROT_INTERP, Fixed_Size_Obj_Pool
*pool)>
Allocate new objects for the given pool.
@@ -586,16 +586,16 @@
*/
static void
-gc_ims_alloc_objects(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_ims_alloc_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_ims_alloc_objects)
- Small_Object_Arena *new_arena;
+ Fixed_Size_Obj_Arena *new_arena;
size_t size;
pool->objects_per_alloc = ALLOCATION_BLOCK_SIZE / pool->object_size;
/* Setup memory for the new objects */
- new_arena = mem_allocate_typed(Small_Object_Arena);
+ new_arena = mem_allocate_typed(Fixed_Size_Obj_Arena);
size = ALLOCATION_BLOCK_SIZE;
new_arena->start_objects = mem_sys_allocate(size);
@@ -607,7 +607,7 @@
/*
-=item C<static void gc_ims_pool_init(PARROT_INTERP, Small_Object_Pool *pool)>
+=item C<static void gc_ims_pool_init(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
Initializes a pool by setting the appropriate function pointers to add, get,
and allocate objects.
@@ -617,7 +617,7 @@
*/
static void
-gc_ims_pool_init(SHIM_INTERP, ARGMOD(Small_Object_Pool *pool))
+gc_ims_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(gc_ims_pool_init)
pool->add_free_object = gc_ims_add_free_object;
@@ -756,7 +756,7 @@
/*
-=item C<static int sweep_cb(PARROT_INTERP, Small_Object_Pool *pool, int flag,
+=item C<static int sweep_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int flag,
void *arg)>
Callback to sweep a header pool (see header_pools_iterate_callback).
@@ -766,7 +766,7 @@
*/
static int
-sweep_cb(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool), int flag, ARGIN(void *arg))
+sweep_cb(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), int flag, ARGIN(void *arg))
{
ASSERT_ARGS(sweep_cb)
int * const n_obj = (int *)arg;
@@ -834,7 +834,7 @@
/*
-=item C<static int collect_cb(PARROT_INTERP, Small_Object_Pool *pool, int flag,
+=item C<static int collect_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int flag,
void *arg)>
Callback to collect a header pool (see header_pools_iterate_callback).
@@ -846,11 +846,11 @@
#if !defined(GC_IS_MALLOC) || !GC_IS_MALLOC
static int
-collect_cb(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool), SHIM(int flag), ARGIN(void *arg))
+collect_cb(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), SHIM(int flag), ARGIN(void *arg))
{
ASSERT_ARGS(collect_cb)
const int check_only = (int)(INTVAL)arg;
- Memory_Pool * const mem_pool = pool->mem_pool;
+ Var_Size_Obj_Pool * const mem_pool = pool->mem_pool;
/* check if there is an associated memory pool */
if (!mem_pool)
Modified: branches/gc-refactor/src/gc/mark_sweep.c
==============================================================================
--- branches/gc-refactor/src/gc/mark_sweep.c Sat Sep 5 19:45:25 2009 (r41014)
+++ branches/gc-refactor/src/gc/mark_sweep.c Sat Sep 5 20:20:31 2009 (r41015)
@@ -32,7 +32,7 @@
/* Don't modify between HEADERIZER BEGIN / HEADERIZER END. Your changes will be lost. */
static void free_buffer(SHIM_INTERP,
- ARGMOD(Small_Object_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
ARGMOD(Buffer *b))
__attribute__nonnull__(2)
__attribute__nonnull__(3)
@@ -40,13 +40,13 @@
FUNC_MODIFIES(*b);
static void free_buffer_malloc(SHIM_INTERP,
- SHIM(Small_Object_Pool *pool),
+ SHIM(Fixed_Size_Obj_Pool *pool),
ARGMOD(Buffer *b))
__attribute__nonnull__(3)
FUNC_MODIFIES(*b);
static void free_pmc_in_pool(PARROT_INTERP,
- SHIM(Small_Object_Pool *pool),
+ SHIM(Fixed_Size_Obj_Pool *pool),
ARGMOD(PObj *p))
__attribute__nonnull__(1)
__attribute__nonnull__(3)
@@ -54,24 +54,24 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-static Small_Object_Pool * new_bufferlike_pool(PARROT_INTERP,
+static Fixed_Size_Obj_Pool * new_bufferlike_pool(PARROT_INTERP,
size_t actual_buffer_size)
__attribute__nonnull__(1);
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-static Small_Object_Pool * new_pmc_pool(PARROT_INTERP)
+static Fixed_Size_Obj_Pool * new_pmc_pool(PARROT_INTERP)
__attribute__nonnull__(1);
PARROT_MALLOC
PARROT_CANNOT_RETURN_NULL
-static Small_Object_Pool * new_small_object_pool(
+static Fixed_Size_Obj_Pool * new_fixed_size_obj_pool(
size_t object_size,
size_t objects_per_alloc);
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-static Small_Object_Pool * new_string_pool(PARROT_INTERP, INTVAL constant)
+static Fixed_Size_Obj_Pool * new_string_pool(PARROT_INTERP, INTVAL constant)
__attribute__nonnull__(1);
static void Parrot_gc_allocate_new_attributes_arena(PARROT_INTERP,
@@ -97,7 +97,7 @@
PARROT_ASSERT_ARG(interp)
#define ASSERT_ARGS_new_pmc_pool __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(interp)
-#define ASSERT_ARGS_new_small_object_pool __attribute__unused__ int _ASSERT_ARGS_CHECK = 0
+#define ASSERT_ARGS_new_fixed_size_obj_pool __attribute__unused__ int _ASSERT_ARGS_CHECK = 0
#define ASSERT_ARGS_new_string_pool __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(interp)
#define ASSERT_ARGS_Parrot_gc_allocate_new_attributes_arena \
@@ -257,7 +257,7 @@
/*
-=item C<void Parrot_gc_sweep_pool(PARROT_INTERP, Small_Object_Pool *pool)>
+=item C<void Parrot_gc_sweep_pool(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
Puts any buffers/PMCs that are marked as "dead" or "black" onto the pool
free list. If C<GC_IS_MALLOC>, bufstart gets freed too, if possible. Avoids
@@ -268,7 +268,7 @@
*/
void
-Parrot_gc_sweep_pool(PARROT_INTERP, ARGMOD(Small_Object_Pool *pool))
+Parrot_gc_sweep_pool(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(Parrot_gc_sweep_pool)
PObj *b;
@@ -276,7 +276,7 @@
UINTVAL total_used = 0;
const UINTVAL object_size = pool->object_size;
- Small_Object_Arena *cur_arena;
+ Fixed_Size_Obj_Arena *cur_arena;
gc_object_fn_type gc_object = pool->gc_object;
#if GC_VERBOSE
@@ -352,7 +352,7 @@
/*
-=item C<INTVAL contained_in_pool(PARROT_INTERP, const Small_Object_Pool *pool,
+=item C<INTVAL contained_in_pool(PARROT_INTERP, const Fixed_Size_Obj_Pool *pool,
const void *ptr)>
Returns whether the given C<*ptr> points to a location in C<pool>.
@@ -363,10 +363,10 @@
PARROT_WARN_UNUSED_RESULT
INTVAL
-contained_in_pool(PARROT_INTERP, ARGIN(const Small_Object_Pool *pool), ARGIN(const void *ptr))
+contained_in_pool(PARROT_INTERP, ARGIN(const Fixed_Size_Obj_Pool *pool), ARGIN(const void *ptr))
{
ASSERT_ARGS(contained_in_pool)
- const Small_Object_Arena *arena;
+ const Fixed_Size_Obj_Arena *arena;
if (interp->gc_sys->PObj_to_Arena){
ptr = interp->gc_sys->PObj_to_Arena(ptr);
@@ -475,7 +475,7 @@
/*
-=item C<void Parrot_gc_clear_live_bits(PARROT_INTERP, const Small_Object_Pool
+=item C<void Parrot_gc_clear_live_bits(PARROT_INTERP, const Fixed_Size_Obj_Pool
*pool)>
Resets the PMC pool, so all objects are marked as "White". This
@@ -487,10 +487,10 @@
*/
void
-Parrot_gc_clear_live_bits(PARROT_INTERP, ARGIN(const Small_Object_Pool *pool))
+Parrot_gc_clear_live_bits(PARROT_INTERP, ARGIN(const Fixed_Size_Obj_Pool *pool))
{
ASSERT_ARGS(Parrot_gc_clear_live_bits)
- Small_Object_Arena *arena;
+ Fixed_Size_Obj_Arena *arena;
const UINTVAL object_size = pool->object_size;
for (arena = pool->last_Arena; arena; arena = arena->prev) {
@@ -584,8 +584,8 @@
/*
-=item C<void Parrot_add_to_free_list(PARROT_INTERP, Small_Object_Pool *pool,
-Small_Object_Arena *arena)>
+=item C<void Parrot_add_to_free_list(PARROT_INTERP, Fixed_Size_Obj_Pool *pool,
+Fixed_Size_Obj_Arena *arena)>
Adds the objects in the newly allocated C<arena> to the free list of the pool.
@@ -595,8 +595,8 @@
void
Parrot_add_to_free_list(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
- ARGMOD(Small_Object_Arena *arena))
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Arena *arena))
{
ASSERT_ARGS(Parrot_add_to_free_list)
UINTVAL i;
@@ -628,8 +628,8 @@
/*
-=item C<void Parrot_append_arena_in_pool(PARROT_INTERP, Small_Object_Pool *pool,
-Small_Object_Arena *new_arena, size_t size)>
+=item C<void Parrot_append_arena_in_pool(PARROT_INTERP, Fixed_Size_Obj_Pool *pool,
+Fixed_Size_Obj_Arena *new_arena, size_t size)>
Insert the new arena into the pool's structure. Arenas are stored in a
linked list, so add the new arena to the list. Set information in the
@@ -641,8 +641,8 @@
void
Parrot_append_arena_in_pool(PARROT_INTERP,
- ARGMOD(Small_Object_Pool *pool),
- ARGMOD(Small_Object_Arena *new_arena), size_t size)
+ ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Obj_Arena *new_arena), size_t size)
{
ASSERT_ARGS(Parrot_append_arena_in_pool)
@@ -728,7 +728,7 @@
=over 4
-=item C<static Small_Object_Pool * new_pmc_pool(PARROT_INTERP)>
+=item C<static Fixed_Size_Obj_Pool * new_pmc_pool(PARROT_INTERP)>
Creates and initializes a new pool for PMCs and returns it.
@@ -738,13 +738,13 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-static Small_Object_Pool *
+static Fixed_Size_Obj_Pool *
new_pmc_pool(PARROT_INTERP)
{
ASSERT_ARGS(new_pmc_pool)
const int num_headers = PMC_HEADERS_PER_ALLOC;
- Small_Object_Pool * const pmc_pool =
- new_small_object_pool(sizeof (PMC), num_headers);
+ Fixed_Size_Obj_Pool * const pmc_pool =
+ new_fixed_size_obj_pool(sizeof (PMC), num_headers);
pmc_pool->mem_pool = NULL;
pmc_pool->gc_object = free_pmc_in_pool;
@@ -755,7 +755,7 @@
/*
-=item C<static void free_pmc_in_pool(PARROT_INTERP, Small_Object_Pool *pool,
+=item C<static void free_pmc_in_pool(PARROT_INTERP, Fixed_Size_Obj_Pool *pool,
PObj *p)>
Frees a PMC that is no longer being used. Calls a custom C<destroy> VTABLE
@@ -766,7 +766,7 @@
*/
static void
-free_pmc_in_pool(PARROT_INTERP, SHIM(Small_Object_Pool *pool),
+free_pmc_in_pool(PARROT_INTERP, SHIM(Fixed_Size_Obj_Pool *pool),
ARGMOD(PObj *p))
{
ASSERT_ARGS(free_pmc_in_pool)
@@ -783,7 +783,7 @@
/*
-=item C<static Small_Object_Pool * new_bufferlike_pool(PARROT_INTERP, size_t
+=item C<static Fixed_Size_Obj_Pool * new_bufferlike_pool(PARROT_INTERP, size_t
actual_buffer_size)>
Creates a new pool for buffer-like structures. This is called from
@@ -795,15 +795,15 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-static Small_Object_Pool *
+static Fixed_Size_Obj_Pool *
new_bufferlike_pool(PARROT_INTERP, size_t actual_buffer_size)
{
ASSERT_ARGS(new_bufferlike_pool)
const int num_headers = BUFFER_HEADERS_PER_ALLOC;
const size_t buffer_size =
(actual_buffer_size + sizeof (void *) - 1) & ~(sizeof (void *) - 1);
- Small_Object_Pool * const pool =
- new_small_object_pool(buffer_size, num_headers);
+ Fixed_Size_Obj_Pool * const pool =
+ new_fixed_size_obj_pool(buffer_size, num_headers);
#ifdef GC_IS_MALLOC
pool->gc_object = free_buffer_malloc;
@@ -818,10 +818,10 @@
/*
-=item C<static Small_Object_Pool * new_small_object_pool(size_t object_size,
+=item C<static Fixed_Size_Obj_Pool * new_fixed_size_obj_pool(size_t object_size,
size_t objects_per_alloc)>
-Creates a new C<Small_Object_Pool> and returns a pointer to it.
+Creates a new C<Fixed_Size_Obj_Pool> and returns a pointer to it.
Initializes the pool structure based on the size of objects in the
pool and the number of items to allocate in each arena.
@@ -831,12 +831,12 @@
PARROT_MALLOC
PARROT_CANNOT_RETURN_NULL
-static Small_Object_Pool *
-new_small_object_pool(size_t object_size, size_t objects_per_alloc)
+static Fixed_Size_Obj_Pool *
+new_fixed_size_obj_pool(size_t object_size, size_t objects_per_alloc)
{
- ASSERT_ARGS(new_small_object_pool)
- Small_Object_Pool * const pool =
- mem_internal_allocate_zeroed_typed(Small_Object_Pool);
+ ASSERT_ARGS(new_fixed_size_obj_pool)
+ Fixed_Size_Obj_Pool * const pool =
+ mem_internal_allocate_zeroed_typed(Fixed_Size_Obj_Pool);
pool->last_Arena = NULL;
pool->free_list = NULL;
@@ -853,7 +853,7 @@
/*
-=item C<static Small_Object_Pool * new_string_pool(PARROT_INTERP, INTVAL
+=item C<static Fixed_Size_Obj_Pool * new_string_pool(PARROT_INTERP, INTVAL
constant)>
Creates a new pool for C<STRING>s and returns it. This calls
@@ -865,11 +865,11 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-static Small_Object_Pool *
+static Fixed_Size_Obj_Pool *
new_string_pool(PARROT_INTERP, INTVAL constant)
{
ASSERT_ARGS(new_string_pool)
- Small_Object_Pool *pool;
+ Fixed_Size_Obj_Pool *pool;
if (constant) {
pool = new_bufferlike_pool(interp, sizeof (STRING));
pool->gc_object = NULL;
@@ -885,7 +885,7 @@
/*
-=item C<static void free_buffer_malloc(PARROT_INTERP, Small_Object_Pool *pool,
+=item C<static void free_buffer_malloc(PARROT_INTERP, Fixed_Size_Obj_Pool *pool,
Buffer *b)>
Frees the given buffer, returning the storage space to the operating system
@@ -897,7 +897,7 @@
*/
static void
-free_buffer_malloc(SHIM_INTERP, SHIM(Small_Object_Pool *pool),
+free_buffer_malloc(SHIM_INTERP, SHIM(Fixed_Size_Obj_Pool *pool),
ARGMOD(Buffer *b))
{
ASSERT_ARGS(free_buffer_malloc)
@@ -921,7 +921,7 @@
/*
-=item C<static void free_buffer(PARROT_INTERP, Small_Object_Pool *pool, Buffer
+=item C<static void free_buffer(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, Buffer
*b)>
Frees a buffer, returning it to the memory pool for Parrot to possibly
@@ -932,10 +932,10 @@
*/
static void
-free_buffer(SHIM_INTERP, ARGMOD(Small_Object_Pool *pool), ARGMOD(Buffer *b))
+free_buffer(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), ARGMOD(Buffer *b))
{
ASSERT_ARGS(free_buffer)
- Memory_Pool * const mem_pool = (Memory_Pool *)pool->mem_pool;
+ Var_Size_Obj_Pool * const mem_pool = (Var_Size_Obj_Pool *)pool->mem_pool;
/* XXX Jarkko reported that on irix pool->mem_pool was NULL, which really
* shouldn't happen */
@@ -952,7 +952,7 @@
/*
-=item C<Small_Object_Pool * get_bufferlike_pool(PARROT_INTERP, size_t
+=item C<Fixed_Size_Obj_Pool * get_bufferlike_pool(PARROT_INTERP, size_t
buffer_size)>
Makes and return a bufferlike header pool for objects of a given size. If a
@@ -965,11 +965,11 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-Small_Object_Pool *
+Fixed_Size_Obj_Pool *
get_bufferlike_pool(PARROT_INTERP, size_t buffer_size)
{
ASSERT_ARGS(get_bufferlike_pool)
- Small_Object_Pool **sized_pools = interp->arena_base->sized_header_pools;
+ Fixed_Size_Obj_Pool **sized_pools = interp->arena_base->sized_header_pools;
const UINTVAL num_old = interp->arena_base->num_sized;
const UINTVAL idx = GET_SIZED_POOL_IDX(buffer_size);
@@ -980,7 +980,7 @@
same debugging behavior as mem_internal_realloc, we would
need to add a new function/macro for
mem_internal_realloc_zeroed, to mirror mem_sys_realloc_zeroed. */
- sized_pools = (Small_Object_Pool **)mem_internal_realloc(sized_pools,
+ sized_pools = (Fixed_Size_Obj_Pool **)mem_internal_realloc(sized_pools,
num_new * sizeof (void *));
memset(sized_pools + num_old, 0, sizeof (void *) * (num_new - num_old));
@@ -1072,7 +1072,7 @@
=item pool_iter_fn
-Called with C<(Parrot_Interp, Small_Object_Pool *, int flag, void *arg)>. If
+Called with C<(Parrot_Interp, Fixed_Size_Obj_Pool *, int flag, void *arg)>. If
the function returns a non-zero value, iteration will stop.
=back
@@ -1090,7 +1090,7 @@
Arenas * const arena_base = interp->arena_base;
if (flag & POOL_PMC) {
- Small_Object_Pool *pool = flag & POOL_CONST
+ Fixed_Size_Obj_Pool *pool = flag & POOL_CONST
? arena_base->constant_pmc_pool
: arena_base->pmc_pool;
@@ -1114,7 +1114,7 @@
}
for (i = interp->arena_base->num_sized - 1; i >= 0; --i) {
- Small_Object_Pool * const pool = arena_base->sized_header_pools[i];
+ Fixed_Size_Obj_Pool * const pool = arena_base->sized_header_pools[i];
if (pool) {
const int ret_val = (func)(interp, pool, POOL_BUFFER, arg);
Modified: branches/gc-refactor/t/op/gc.t
==============================================================================
--- branches/gc-refactor/t/op/gc.t Sat Sep 5 19:45:25 2009 (r41014)
+++ branches/gc-refactor/t/op/gc.t Sat Sep 5 20:20:31 2009 (r41015)
@@ -1,6 +1,6 @@
#! parrot
# Copyright (C) 2001-2009, Parrot Foundation.
-# $Id: string.t 40481 2009-08-11 06:09:35Z dukeleto $
+# $Id$
=head1 NAME
More information about the parrot-commits
mailing list