[svn:parrot] r41088 - in branches/gc-refactor: docs docs/pdds include/parrot src/gc src/interp t/tools/ops2pm/samples
jrtayloriv at svn.parrot.org
jrtayloriv at svn.parrot.org
Mon Sep 7 01:02:29 UTC 2009
Author: jrtayloriv
Date: Mon Sep 7 01:02:27 2009
New Revision: 41088
URL: https://trac.parrot.org/parrot/changeset/41088
Log:
Renamed Arenas to Memory_Pools, renamed Fixed_Size_Obj_Pool to Fixed_Size_Pool, updated pdd09 and memory_internals.pod
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/include/parrot/interpreter.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/src/gc/res_lea.c
branches/gc-refactor/src/gc/system.c
branches/gc-refactor/src/interp/inter_create.c
branches/gc-refactor/t/tools/ops2pm/samples/core_ops.original
Modified: branches/gc-refactor/docs/memory_internals.pod
==============================================================================
--- branches/gc-refactor/docs/memory_internals.pod Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/docs/memory_internals.pod Mon Sep 7 01:02:27 2009 (r41088)
@@ -51,31 +51,31 @@
typedef struct Interp {
...
- struct Arenas *arena_base;
+ struct Memory_Pools *mem_pools;
...
} Interp;
All object-like things that get allocated during the execution of parrot
-bytecode are managed from the C<arena_base> member of the interpreter
+bytecode are managed from the C<mem_pools> member of the interpreter
structure.
-=head1 Arenas
+=head1 Memory Pools
-C<struct Arenas> holds pointers to a variety of different kinds of managed
+C<struct Memory_Pools> holds pointers to a variety of different kinds of managed
memory. A simplification looks similar to this:
- typedef struct Arenas {
- struct Var_Size_Obj_Pool *memory_pool;
+ typedef struct Memory_Pools {
+ struct Var_Size_Pool *memory_pool;
...
- struct Fixed_Size_Obj_Pool * header_pool;
- struct Fixed_Size_Obj_Pool ** sized_pools;
- } Arenas;
+ struct Fixed_Size_Pool * header_pool;
+ struct Fixed_Size_Pool ** sized_pools;
+ } Memory_Pools;
C<memory_pool> and C<header_pool> are variable and fixed sized pool pointers
-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
+respectively. These are just two examples, there are other C<Var_Size_Pool>s
+and C<Fixed_Size_Pool>s in the Parrot system. Pools of type
+C<struct Var_Size_Pool> are for variable-size objects, such as constant string
+buffers. Pools of type C<struct Fixed_Size_Pool> are for fixed-size objects
such as headers or PMCs.
=head1 Fixed sized items
@@ -135,28 +135,18 @@
flags are stored in C<PObj-E<gt>flags>, meaning that each PMC must be accessed
during the mark run.
-An alternative approach is to store the GC-Flags together somewhere, such as
-in the individual arenas, as a packed array of bits. This approach, called
-cardmarking, should be indicated by defining the preprocessor variable
-C<ARENA_GC_FLAGS> to 1.
-
-{{ ARENA_GC_FLAGS (nee ARENA_DOD_FLAGS) seems to have been deprecated or
-changed without concomitant update to this document. Someone should figure out
-what this macro used to be and whether it's still relevant. -cotto }}
-
F<pobj.h> provides macros to facilitate referencing individual object flags:
C<gc_flag_SET>, C<gc_flag_CLEAR> and C<gc_flag_TEST>. They make up a portable
way of manipulating the GC-relevant object flags.
=head1 Variable sized items
-Variable-sized items do not exist by themselves, they are always preceded by
-a buffer structure that contains information about them. These buffer
-structures are described above, and the C<UnionVal cache> item typically
-points to the memory block that contains the data. The variable-sized data
-items are managed in two different pools: the C<memory_pool>, which contains
-a general mish-mash of data types, and the C<constant_string_pool> which
-contains immutable string buffers used by programs running on Parrot.
+Variable-sized items do not exist by themselves, they are always wrapped by
+a buffer structure that contains a pointer to the data information about them.
+The variable-sized data items are managed in two different pools: the
+C<memory_pool>, which contains a general mish-mash of data types, and the
+C<constant_string_pool> which contains immutable string buffers used by
+programs running on Parrot.
Here, different memory allocation schemes jump in:
@@ -221,11 +211,6 @@
once. Both allocation schemes therefore use a part of the allocated string to
do this bookkeeping.
-Copying GC uses a C<Buffer_Tail> after the end of the actual variable length
-string and marks such COW strings with C<TAIL_moved> and stores the new address
-in the buffer header, so other users of this string can be updated to reuse the
-same string (RT#47764 one or all other users?).
-
The C<malloc()>/C<free()> approach stores a refcount at C<bufstart>. During the
mark phase all dead users increment the refcount, living users set it to an
huge value. When freeing the buffer, the string is only freed if the refcount
@@ -233,9 +218,9 @@
=head1 Simplified Figure
- +--------+
- +------------------<---| Arenas |<-----------+
- | +--------+-->--+ |
+ +--------------+
+ +--------------<---| Memory Pools |<---------+
+ | +--------------+---+ |
| | |
| +------+ +-----------+ | +=============+
| | S0 |<---| Registers |<--)--| Interpreter |
@@ -249,8 +234,8 @@
+-------+ | | Buffer 2 | | ..String... |<--| Block 2 |
| . | | +----------+ +--------------+ +---------+
+-------+ | | ... | ^ ^ | ... |
- Small Obj | +----------+ | | +---------+
- Pool +-->| Buffer N |--------+----+ Memory Pool
+Fixed Size | +----------+ | | +---------+
+ Pool +-->| Buffer N |--------+----+ Var Size Pool
+----------+
Buffer Memory Block
@@ -261,9 +246,9 @@
=head1 FILES
-mark_sweep.[ch], src/gc/pools.c, resources.[ch], res_lea.c, src/gc/api.c,
-string.[ch], pobj.h. Other garbage collector implementations may use separate
-files as well.
+src/gc/api.c, src/gc/gc_private.h, pobj.h, mark_sweep.[ch],
+alloc_resources.[ch], res_lea.c, string.[ch]. Other garbage collector
+implementations may use separate files as well.
=head1 BUGS
Modified: branches/gc-refactor/docs/pdds/pdd09_gc.pod
==============================================================================
--- branches/gc-refactor/docs/pdds/pdd09_gc.pod Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/docs/pdds/pdd09_gc.pod Mon Sep 7 01:02:27 2009 (r41088)
@@ -279,41 +279,42 @@
resources. The arena structures and arena creation routines are common across
most GC cores, and some GC cores also share mark routines.
-The main interpreter structure has an arena_base member, which is a pointer to
-an Arenas struct.
+The main interpreter structure has an mem_pools member, which is a pointer to
+an Memory_Pools struct.
-=head4 The Arenas structure
+=head4 The Memory_Pools structure
-The Arenas structure contains pointers to a variety of memory pools, each used
-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,
+The C<Memory_Pools> structure contains pointers to a variety of memory pools,
+each used for a specific purpose. Two are Var_Size_Pool pointers (memory_pool,
+constant_string_pool), and six are Fixed_Size_Pool structures (pmc_pool,
constant_pmc_pool, constant_string_header_pool).
-The Arenas structure holds function pointers for the core defined interface of
-the currently active GC subsystem: C<init_pool>, C<do_gc_mark>,
+The C<Memory_Pools> structure holds function pointers for the core defined
+interface of the currently active GC subsystem: C<init_pool>, C<do_gc_mark>,
C<finalize_gc_system>. It holds various accounting information for the GC
subsystem, including how many GC runs have been completed, amount of memory
allocated since the last run, and total memory allocated. This accounting
information is updated by the GC system. The current block level for GC mark
-and sweep phases is stored in the Arenas structure. (See L<Blocking GC>.)
+and sweep phases is stored in the C<Memory_Pools> structure.
+(See L<Blocking GC>.)
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 Var_Size_Obj_Pool structure
+=head4 The Var_Size_Pool structure
-The Var_Size_Obj_Pool structure is a simple memory pool. It contains a pointer
+The C<Var_Size_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 Fixed_Size_Obj_Pool structure
+=head4 The Fixed_Size_Pool structure
-The Fixed_Size_Obj_Pool structure is a richer memory pool for object
+The C<Fixed_Size_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 Var_Size_Obj_Pool (the base storage of the
+contains a pointer to a simple C<Var_Size_Pool> (the base storage of the
pool). It holds function pointers for adding and retrieving free objects in
the pool, and for allocating objects.
@@ -333,7 +334,7 @@
Each GC core declares an initialization routine as a function pointer,
which is installed in F<src/memory.c:mem_setup_allocator()> after
-creating C<arena_base> in the interpreter struct.
+creating C<mem_pools> in the interpreter struct.
=over 4
@@ -342,22 +343,22 @@
A routine to initialize the GC system named C<XXX>.
The initialization code is responsible for the creation of the header pools
-and fills the function pointer slots in the interpreter's C<arena_base>
+and fills the function pointer slots in the interpreter's C<mem_pools>
member.
=back
-=head4 Arenas structure function pointers
+=head4 Memory_Pools structure function pointers
-Each GC system declares 3 function pointers, stored in the Arenas structure.
+Each GC system declares 3 function pointers, stored in the Memory_Pools structure.
=over 4
=item C<void (*init_gc_system) (Interp *)>
Initialize the GC system. Install the additional function pointers into
-the Arenas structure, and prepare any private storage to be used by
-the GC in the Arenas->gc_private field.
+the Memory_Pools structure, and prepare any private storage to be used by
+the GC in the Memory_Pools->gc_private field.
=item C<void (*do_gc_mark) (Interp *, int flags)>
@@ -422,23 +423,23 @@
All PMCs must be swept, and PMCs with custom destroy VTABLE methods must have
those called.
-=item C<void (*init_pool) (Interp *, Fixed_Size_Obj_Pool *)>
+=item C<void (*init_pool) (Interp *, Fixed_Size_Pool *)>
-Initialize the given pool. Populates the C<Fixed_Size_Obj_Pool> structure with
+Initialize the given pool. Populates the C<Fixed_Size_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 Fixed_Size_Obj_Pool function pointers
+=head4 Fixed_Size_Pool function pointers
-Each GC core defines 4 function pointers stored in the C<Fixed_Size_Obj_Pool>
+Each GC core defines 4 function pointers stored in the C<Fixed_Size_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 *, Fixed_Size_Obj_Pool*)>
+=item C<PObj * (*get_free_object) (Interp *, Fixed_Size_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
@@ -446,20 +447,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 *, Fixed_Size_Obj_Pool *, PObj *);>
+=item C<void (*add_free_object) (Interp *, Fixed_Size_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 *, Fixed_Size_Obj_Pool *);>
+=item C<void (*alloc_objects) (Interp *, Fixed_Size_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 *, Fixed_Size_Obj_Pool *);>
+=item C<void (*more_objects) (Interp *, Fixed_Size_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 Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/include/parrot/gc_api.h Mon Sep 7 01:02:27 2009 (r41088)
@@ -53,10 +53,10 @@
} pool_iter_enum;
struct Memory_Block;
-struct Var_Size_Obj_Pool;
-struct Fixed_Size_Obj_Pool;
-struct Fixed_Size_Obj_Arena;
-struct Arenas;
+struct Var_Size_Pool;
+struct Fixed_Size_Pool;
+struct Fixed_Size_Arena;
+struct Memory_Pools;
typedef enum {
GC_TRACE_FULL = 1,
@@ -64,11 +64,11 @@
GC_TRACE_SYSTEM_ONLY = 3
} Parrot_gc_trace_type;
-typedef int (*pool_iter_fn)(PARROT_INTERP, struct Fixed_Size_Obj_Pool *, int, void*);
-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 *);
+typedef int (*pool_iter_fn)(PARROT_INTERP, struct Fixed_Size_Pool *, int, void*);
+typedef void (*add_free_object_fn_type)(PARROT_INTERP, struct Fixed_Size_Pool *, void *);
+typedef void * (*get_free_object_fn_type)(PARROT_INTERP, struct Fixed_Size_Pool *);
+typedef void (*alloc_objects_fn_type)(PARROT_INTERP, struct Fixed_Size_Pool *);
+typedef void (*gc_object_fn_type)(PARROT_INTERP, struct Fixed_Size_Pool *, PObj *);
/* &gen_from_enum(interpinfo.pasm) prefix(INTERPINFO_) */
Modified: branches/gc-refactor/include/parrot/interpreter.h
==============================================================================
--- branches/gc-refactor/include/parrot/interpreter.h Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/include/parrot/interpreter.h Mon Sep 7 01:02:27 2009 (r41088)
@@ -218,7 +218,7 @@
struct parrot_interp_t {
PMC *ctx; /* current Context */
- struct Arenas *arena_base; /* Pointer to this interpreter's
+ struct Memory_Pools *mem_pools; /* Pointer to this interpreter's
* arena */
struct GC_Subsystem *gc_sys; /*functions and data specific
Modified: branches/gc-refactor/src/gc/alloc_resources.c
==============================================================================
--- branches/gc-refactor/src/gc/alloc_resources.c Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/src/gc/alloc_resources.c Mon Sep 7 01:02:27 2009 (r41088)
@@ -32,7 +32,7 @@
#define POOL_SIZE 65536 * 2
-typedef void (*compact_f) (Interp *, Var_Size_Obj_Pool *);
+typedef void (*compact_f) (Interp *, Variable_Size_Pool *);
/* HEADERIZER HFILE: src/gc/gc_private.h */
@@ -41,7 +41,7 @@
static void alloc_new_block(PARROT_INTERP,
size_t size,
- ARGMOD(Var_Size_Obj_Pool *pool),
+ ARGMOD(Variable_Size_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_var_size_obj_pool(ARGMOD(Var_Size_Obj_Pool *pool))
+static void check_var_size_obj_pool(ARGMOD(Variable_Size_Pool *pool))
__attribute__nonnull__(1)
FUNC_MODIFIES(*pool);
static void check_memory_system(PARROT_INTERP)
__attribute__nonnull__(1);
-static void check_fixed_size_obj_pool(ARGMOD(Fixed_Size_Obj_Pool * pool))
+static void check_fixed_size_obj_pool(ARGMOD(Fixed_Size_Pool * pool))
__attribute__nonnull__(1)
FUNC_MODIFIES(* pool);
@@ -71,7 +71,7 @@
PARROT_MALLOC
PARROT_CANNOT_RETURN_NULL
-static Var_Size_Obj_Pool * new_memory_pool(
+static Variable_Size_Pool * new_memory_pool(
size_t min_block,
NULLOK(compact_f compact));
@@ -98,7 +98,7 @@
/*
-=item C<static void alloc_new_block(PARROT_INTERP, size_t size, Var_Size_Obj_Pool
+=item C<static void alloc_new_block(PARROT_INTERP, size_t size, Variable_Size_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(Var_Size_Obj_Pool *pool),
+alloc_new_block(PARROT_INTERP, size_t size, ARGMOD(Variable_Size_Pool *pool),
ARGIN(const char *why))
{
ASSERT_ARGS(alloc_new_block)
@@ -143,7 +143,7 @@
new_block->top = new_block->start;
/* Note that we've allocated it */
- interp->arena_base->memory_allocated += alloc_size;
+ interp->mem_pools->memory_allocated += alloc_size;
/* If this is for a public pool, add it to the list */
new_block->prev = pool->top_block;
@@ -158,7 +158,7 @@
/*
-=item C<void * mem_allocate(PARROT_INTERP, size_t size, Var_Size_Obj_Pool *pool)>
+=item C<void * mem_allocate(PARROT_INTERP, size_t size, Variable_Size_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(Var_Size_Obj_Pool *pool))
+mem_allocate(PARROT_INTERP, size_t size, ARGMOD(Variable_Size_Pool *pool))
{
ASSERT_ARGS(mem_allocate)
void *return_val;
@@ -213,8 +213,8 @@
* TODO pass required allocation size to the GC system,
* so that collection can be skipped if needed
*/
- if (!interp->arena_base->gc_mark_block_level
- && interp->arena_base->mem_allocs_since_last_collect) {
+ if (!interp->mem_pools->gc_mark_block_level
+ && interp->mem_pools->mem_allocs_since_last_collect) {
Parrot_gc_mark_and_sweep(interp, GC_trace_stack_FLAG);
if ((interp->gc_sys->sys_type != IMS) &&
@@ -240,7 +240,7 @@
*/
alloc_new_block(interp, size, pool, "compact failed");
- interp->arena_base->mem_allocs_since_last_collect++;
+ interp->mem_pools->mem_allocs_since_last_collect++;
if (pool->top_block->free < size) {
fprintf(stderr, "out of mem\n");
@@ -320,7 +320,7 @@
=over 4
-=item C<void compact_pool(PARROT_INTERP, Var_Size_Obj_Pool *pool)>
+=item C<void compact_pool(PARROT_INTERP, Variable_Size_Pool *pool)>
Compact the string buffer pool. Does not perform a GC scan, or mark items
as being alive in any way.
@@ -330,7 +330,7 @@
*/
void
-compact_pool(PARROT_INTERP, ARGMOD(Var_Size_Obj_Pool *pool))
+compact_pool(PARROT_INTERP, ARGMOD(Variable_Size_Pool *pool))
{
ASSERT_ARGS(compact_pool)
INTVAL j;
@@ -340,21 +340,21 @@
char *cur_spot; /* Where we're currently copying to */
Fixed_Size_Obj_Arena *cur_buffer_arena;
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
/* Bail if we're blocked */
- if (arena_base->gc_sweep_block_level)
+ if (mem_pools->gc_sweep_block_level)
return;
- ++arena_base->gc_sweep_block_level;
+ ++mem_pools->gc_sweep_block_level;
if (interp->profile)
Parrot_gc_profile_start(interp);
/* We're collecting */
- arena_base->mem_allocs_since_last_collect = 0;
- arena_base->header_allocs_since_last_collect = 0;
- arena_base->gc_collect_runs++;
+ mem_pools->mem_allocs_since_last_collect = 0;
+ mem_pools->header_allocs_since_last_collect = 0;
+ mem_pools->gc_collect_runs++;
/* total - reclaimable == currently used. Add a minimum block to the
* current amount, so we can avoid having to allocate it in the future. */
@@ -406,8 +406,8 @@
cur_spot = new_block->start;
/* Run through all the Buffer header pools and copy */
- for (j = (INTVAL)arena_base->num_sized - 1; j >= 0; --j) {
- Fixed_Size_Obj_Pool * const header_pool = arena_base->sized_header_pools[j];
+ for (j = (INTVAL)mem_pools->num_sized - 1; j >= 0; --j) {
+ Fixed_Size_Pool * const header_pool = mem_pools->sized_header_pools[j];
UINTVAL object_size;
if (!header_pool)
@@ -533,7 +533,7 @@
/* How much is free. That's the total size minus the amount we used */
new_block->free = new_block->size - (new_block->top - new_block->start);
- arena_base->memory_collected += (new_block->top - new_block->start);
+ mem_pools->memory_collected += (new_block->top - new_block->start);
/* Now we're done. We're already on the pool's free list, so let us be the
* only one on the free list and free the rest */
@@ -546,7 +546,7 @@
Memory_Block * const next_block = cur_block->prev;
/* Note that we don't have it any more */
- arena_base->memory_allocated -= cur_block->size;
+ mem_pools->memory_allocated -= cur_block->size;
/* We know the pool body and pool header are a single chunk, so
* this is enough to get rid of 'em both */
@@ -565,7 +565,7 @@
if (interp->profile)
Parrot_gc_profile_end(interp, PARROT_PROF_GC);
- --arena_base->gc_sweep_block_level;
+ --mem_pools->gc_sweep_block_level;
}
/*
@@ -654,10 +654,10 @@
=over 4
-=item C<static Var_Size_Obj_Pool * new_memory_pool(size_t min_block, compact_f
+=item C<static Variable_Size_Pool * new_memory_pool(size_t min_block, compact_f
compact)>
-Allocate a new C<Var_Size_Obj_Pool> structures, and set some initial values.
+Allocate a new C<Variable_Size_Pool> structures, and set some initial values.
return a pointer to the new pool.
=cut
@@ -666,11 +666,11 @@
PARROT_MALLOC
PARROT_CANNOT_RETURN_NULL
-static Var_Size_Obj_Pool *
+static Variable_Size_Pool *
new_memory_pool(size_t min_block, NULLOK(compact_f compact))
{
ASSERT_ARGS(new_memory_pool)
- Var_Size_Obj_Pool * const pool = mem_internal_allocate_typed(Var_Size_Obj_Pool);
+ Variable_Size_Pool * const pool = mem_internal_allocate_typed(Variable_Size_Pool);
pool->top_block = NULL;
pool->compact = compact;
@@ -685,9 +685,9 @@
/*
-=item C<void initialize_memory_pools(PARROT_INTERP)>
+=item C<void initialize_var_size_pools(PARROT_INTERP)>
-Initialize the managed memory pools. Parrot maintains two C<Var_Size_Obj_Pool>
+Initialize the managed memory pools. Parrot maintains two C<Variable_Size_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.
@@ -697,23 +697,23 @@
*/
void
-initialize_memory_pools(PARROT_INTERP)
+initialize_var_size_pools(PARROT_INTERP)
{
- ASSERT_ARGS(initialize_memory_pools)
- Arenas * const arena_base = interp->arena_base;
+ ASSERT_ARGS(initialize_var_size_pools)
+ Memory_Pools * const mem_pools = interp->mem_pools;
- arena_base->memory_pool = new_memory_pool(POOL_SIZE, &compact_pool);
- alloc_new_block(interp, POOL_SIZE, arena_base->memory_pool, "init");
+ mem_pools->memory_pool = new_memory_pool(POOL_SIZE, &compact_pool);
+ alloc_new_block(interp, POOL_SIZE, mem_pools->memory_pool, "init");
/* Constant strings - not compacted */
- arena_base->constant_string_pool = new_memory_pool(POOL_SIZE, NULL);
- alloc_new_block(interp, POOL_SIZE, arena_base->constant_string_pool, "init");
+ mem_pools->constant_string_pool = new_memory_pool(POOL_SIZE, NULL);
+ alloc_new_block(interp, POOL_SIZE, mem_pools->constant_string_pool, "init");
}
/*
-=item C<void merge_pools(Var_Size_Obj_Pool *dest, Var_Size_Obj_Pool *source)>
+=item C<void merge_pools(Variable_Size_Pool *dest, Variable_Size_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
@@ -724,7 +724,7 @@
*/
void
-merge_pools(ARGMOD(Var_Size_Obj_Pool *dest), ARGMOD(Var_Size_Obj_Pool *source))
+merge_pools(ARGMOD(Variable_Size_Pool *dest), ARGMOD(Variable_Size_Pool *source))
{
ASSERT_ARGS(merge_pools)
Memory_Block *cur_block;
@@ -771,25 +771,25 @@
{
ASSERT_ARGS(check_memory_system)
size_t i;
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
- 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++) {
- Fixed_Size_Obj_Pool * pool = arena_base->sized_header_pools[i];
- if (pool != NULL && pool != arena_base->string_header_pool)
+ check_var_size_obj_pool(mem_pools->memory_pool);
+ check_var_size_obj_pool(mem_pools->constant_string_pool);
+ check_fixed_size_obj_pool(mem_pools->pmc_pool);
+ check_fixed_size_obj_pool(mem_pools->constant_pmc_pool);
+ check_fixed_size_obj_pool(mem_pools->string_header_pool);
+ check_fixed_size_obj_pool(mem_pools->constant_string_header_pool);
+
+ for (i = 0; i < mem_pools->num_sized; i++) {
+ Fixed_Size_Pool * pool = mem_pools->sized_header_pools[i];
+ if (pool != NULL && pool != mem_pools->string_header_pool)
check_fixed_size_obj_pool(pool);
}
}
/*
-=item C<static void check_fixed_size_obj_pool(Fixed_Size_Obj_Pool * pool)>
+=item C<static void check_fixed_size_obj_pool(Fixed_Size_Pool * pool)>
Checks a small object pool, if it contains buffer it checks the buffers also.
@@ -798,7 +798,7 @@
*/
static void
-check_fixed_size_obj_pool(ARGMOD(Fixed_Size_Obj_Pool * pool))
+check_fixed_size_obj_pool(ARGMOD(Fixed_Size_Pool * pool))
{
ASSERT_ARGS(check_fixed_size_obj_pool)
size_t total_objects;
@@ -868,7 +868,7 @@
/*
-=item C<static void check_var_size_obj_pool(Var_Size_Obj_Pool *pool)>
+=item C<static void check_var_size_obj_pool(Variable_Size_Pool *pool)>
Checks a memory pool, containing buffer data
@@ -877,7 +877,7 @@
*/
static void
-check_var_size_obj_pool(ARGMOD(Var_Size_Obj_Pool *pool))
+check_var_size_obj_pool(ARGMOD(Variable_Size_Pool *pool))
{
ASSERT_ARGS(check_var_size_obj_pool)
size_t count;
@@ -901,7 +901,7 @@
/*
-=item C<void check_buffer_ptr(Buffer * pobj, Var_Size_Obj_Pool * pool)>
+=item C<void check_buffer_ptr(Buffer * pobj, Variable_Size_Pool * pool)>
Checks wether the buffer is within the bounds of the memory pool
@@ -910,7 +910,7 @@
*/
void
-check_buffer_ptr(ARGMOD(Buffer * pobj), ARGMOD(Var_Size_Obj_Pool * pool))
+check_buffer_ptr(ARGMOD(Buffer * pobj), ARGMOD(Variable_Size_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 Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/src/gc/api.c Mon Sep 7 01:02:27 2009 (r41088)
@@ -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 Var_Size_Obj_Pool structures, and use
+buffers. String storage is managed by special Variable_Size_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(Fixed_Size_Obj_Pool *pool))
+static void cleanup_next_for_GC_pool(ARGIN(Fixed_Size_Pool *pool))
__attribute__nonnull__(1);
static void fix_pmc_syncs(
ARGMOD(Interp *dest_interp),
- ARGIN(Fixed_Size_Obj_Pool *pool))
+ ARGIN(Fixed_Size_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*dest_interp);
-static void free_pool(ARGMOD(Fixed_Size_Obj_Pool *pool))
+static void free_pool(ARGMOD(Fixed_Size_Pool *pool))
__attribute__nonnull__(1)
FUNC_MODIFIES(*pool);
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-static void * get_free_buffer(PARROT_INTERP, ARGIN(Fixed_Size_Obj_Pool *pool))
+static void * get_free_buffer(PARROT_INTERP, ARGIN(Fixed_Size_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2);
static void Parrot_gc_merge_buffer_pools(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *dest),
- ARGMOD(Fixed_Size_Obj_Pool *source))
+ ARGMOD(Fixed_Size_Pool *dest),
+ ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Pool *pool),
SHIM(int flag),
SHIM(void *arg))
__attribute__nonnull__(1)
@@ -196,7 +196,7 @@
{
ASSERT_ARGS(Parrot_gc_mark_PObj_alive)
/* TODO: Have each core register a ->pobject_lives function pointer in the
- Arenas struct, and call that pointer directly instead of having a messy
+ Memory_Pools struct, and call that pointer directly instead of having a messy
set of #if preparser conditions. */
if (interp->gc_sys->sys_type == GMS) {
@@ -265,11 +265,11 @@
Parrot_gc_initialize(PARROT_INTERP, ARGIN(void *stacktop))
{
ASSERT_ARGS(Parrot_gc_initialize)
- interp->arena_base = mem_allocate_zeroed_typed(Arenas);
- interp->arena_base->sized_header_pools = NULL;
- interp->arena_base->num_sized = 0;
- interp->arena_base->attrib_pools = NULL;
- interp->arena_base->num_attribs = 0;
+ interp->mem_pools = mem_allocate_zeroed_typed(Memory_Pools);
+ interp->mem_pools->sized_header_pools = NULL;
+ interp->mem_pools->num_sized = 0;
+ interp->mem_pools->attrib_pools = NULL;
+ interp->mem_pools->num_attribs = 0;
interp->lo_var_ptr = stacktop;
@@ -306,8 +306,8 @@
break; /*What SHOULD we be doing if we get here?*/
}
- initialize_memory_pools(interp);
- initialize_header_pools(interp);
+ initialize_var_size_pools(interp);
+ initialize_fixed_size_pools(interp);
}
/*
@@ -348,9 +348,9 @@
Parrot_gc_new_pmc_header(PARROT_INTERP, UINTVAL flags)
{
ASSERT_ARGS(Parrot_gc_new_pmc_header)
- Fixed_Size_Obj_Pool * const pool = flags & PObj_constant_FLAG
- ? interp->arena_base->constant_pmc_pool
- : interp->arena_base->pmc_pool;
+ Fixed_Size_Pool * const pool = flags & PObj_constant_FLAG
+ ? interp->mem_pools->constant_pmc_pool
+ : interp->mem_pools->pmc_pool;
PMC * const pmc = (PMC *)pool->get_free_object(interp, pool);
if (!pmc)
@@ -383,8 +383,8 @@
Parrot_gc_free_pmc_header(PARROT_INTERP, ARGMOD(PMC *pmc))
{
ASSERT_ARGS(Parrot_gc_free_pmc_header)
- Fixed_Size_Obj_Pool * const pool = (PObj_constant_TEST(pmc)) ?
- interp->arena_base->constant_pmc_pool : interp->arena_base->pmc_pool;
+ Fixed_Size_Pool * const pool = (PObj_constant_TEST(pmc)) ?
+ interp->mem_pools->constant_pmc_pool : interp->mem_pools->pmc_pool;
Parrot_pmc_destroy(interp, pmc);
@@ -468,8 +468,8 @@
STRING * const string = (STRING *)get_free_buffer(interp,
(flags & PObj_constant_FLAG)
- ? interp->arena_base->constant_string_header_pool
- : interp->arena_base->string_header_pool);
+ ? interp->mem_pools->constant_string_header_pool
+ : interp->mem_pools->string_header_pool);
if (!string)
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_ALLOCATION_ERROR,
"Parrot VM: STRING allocation failed!\n");
@@ -496,7 +496,7 @@
{
ASSERT_ARGS(Parrot_gc_free_string_header)
if (!PObj_constant_TEST(s)) {
- Fixed_Size_Obj_Pool * const pool = interp->arena_base->string_header_pool;
+ Fixed_Size_Pool * const pool = interp->mem_pools->string_header_pool;
pool->add_free_object(interp, pool, s);
}
}
@@ -521,14 +521,14 @@
{
ASSERT_ARGS(Parrot_gc_new_bufferlike_header)
- Fixed_Size_Obj_Pool * const pool = get_bufferlike_pool(interp, size);
+ Fixed_Size_Pool * const pool = get_bufferlike_pool(interp, size);
return get_free_buffer(interp, pool);
}
/*
-=item C<static void * get_free_buffer(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
+=item C<static void * get_free_buffer(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool))
+get_free_buffer(PARROT_INTERP, ARGIN(Fixed_Size_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)
- Fixed_Size_Obj_Pool * const pool = get_bufferlike_pool(interp, size);
+ Fixed_Size_Pool * const pool = get_bufferlike_pool(interp, size);
pool->add_free_object(interp, pool, obj);
}
@@ -603,7 +603,7 @@
Buffer_bufstart(buffer) = NULL;
new_size = aligned_size(buffer, size);
mem = (char *)mem_allocate(interp, new_size,
- interp->arena_base->memory_pool);
+ interp->mem_pools->memory_pool);
mem = aligned_mem(buffer, mem);
Buffer_bufstart(buffer) = mem;
if (PObj_is_COWable_TEST(buffer))
@@ -633,7 +633,7 @@
ASSERT_ARGS(Parrot_gc_reallocate_buffer_storage)
size_t copysize;
char *mem;
- Var_Size_Obj_Pool * const pool = interp->arena_base->memory_pool;
+ Variable_Size_Pool * const pool = interp->mem_pools->memory_pool;
size_t new_size, needed, old_size;
/*
@@ -704,7 +704,7 @@
{
ASSERT_ARGS(Parrot_gc_allocate_string_storage)
size_t new_size;
- Var_Size_Obj_Pool *pool;
+ Variable_Size_Pool *pool;
char *mem;
Buffer_buflen(str) = 0;
@@ -718,8 +718,8 @@
return;
pool = PObj_constant_TEST(str)
- ? interp->arena_base->constant_string_pool
- : interp->arena_base->memory_pool;
+ ? interp->mem_pools->constant_string_pool
+ : interp->mem_pools->memory_pool;
new_size = aligned_string_size(size);
mem = (char *)mem_allocate(interp, new_size, pool);
@@ -751,10 +751,10 @@
char *mem, *oldmem;
size_t new_size, needed, old_size;
- Var_Size_Obj_Pool * const pool =
+ Variable_Size_Pool * const pool =
PObj_constant_TEST(str)
- ? interp->arena_base->constant_string_pool
- : interp->arena_base->memory_pool;
+ ? interp->mem_pools->constant_string_pool
+ : interp->mem_pools->memory_pool;
/* if the requested size is smaller then buflen, we are done */
if (newsize <= Buffer_buflen(str))
@@ -836,7 +836,7 @@
Parrot_gc_compact_memory_pool(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_compact_memory_pool)
- compact_pool(interp, interp->arena_base->memory_pool);
+ compact_pool(interp, interp->mem_pools->memory_pool);
}
/*
@@ -857,8 +857,8 @@
{
ASSERT_ARGS(Parrot_gc_merge_header_pools)
- Arenas * const dest_arena = dest_interp->arena_base;
- Arenas * const source_arena = source_interp->arena_base;
+ Memory_Pools * const dest_arena = dest_interp->mem_pools;
+ Memory_Pools * const source_arena = source_interp->mem_pools;
UINTVAL i;
/* heavily borrowed from forall_header_pools */
@@ -880,7 +880,7 @@
if (i >= dest_arena->num_sized
|| !dest_arena->sized_header_pools[i]) {
- Fixed_Size_Obj_Pool *ignored = get_bufferlike_pool(dest_interp,
+ Fixed_Size_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,
-Fixed_Size_Obj_Pool *dest, Fixed_Size_Obj_Pool *source)>
+Fixed_Size_Pool *dest, Fixed_Size_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,7 +908,7 @@
static void
Parrot_gc_merge_buffer_pools(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *dest), ARGMOD(Fixed_Size_Obj_Pool *source))
+ ARGMOD(Fixed_Size_Pool *dest), ARGMOD(Fixed_Size_Pool *source))
{
ASSERT_ARGS(Parrot_gc_merge_buffer_pools)
Fixed_Size_Obj_Arena *cur_arena;
@@ -962,7 +962,7 @@
/*
-=item C<static void fix_pmc_syncs(Interp *dest_interp, Fixed_Size_Obj_Pool *pool)>
+=item C<static void fix_pmc_syncs(Interp *dest_interp, Fixed_Size_Pool *pool)>
Walks through the given arena, looking for all live and shared PMCs,
transferring their sync values to the destination interpreter.
@@ -972,7 +972,7 @@
*/
static void
-fix_pmc_syncs(ARGMOD(Interp *dest_interp), ARGIN(Fixed_Size_Obj_Pool *pool))
+fix_pmc_syncs(ARGMOD(Interp *dest_interp), ARGIN(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(fix_pmc_syncs)
Fixed_Size_Obj_Arena *cur_arena;
@@ -1006,7 +1006,7 @@
Performs a garbage collection sweep on all pools, then frees them. Calls
C<header_pools_iterate_callback> to loop over all the pools, passing
C<sweep_cb_pmc> and C<sweep_cb_buf> callback routines. Frees the array of sized
-header pointers in the C<Arenas> structure too.
+header pointers in the C<Memory_Pools> structure too.
=cut
@@ -1038,16 +1038,16 @@
(void *)pass, sweep_cb_buf);
}
- mem_internal_free(interp->arena_base->sized_header_pools);
- if (interp->arena_base->attrib_pools)
- mem_internal_free(interp->arena_base->attrib_pools);
- interp->arena_base->attrib_pools = NULL;
- interp->arena_base->sized_header_pools = NULL;
+ mem_internal_free(interp->mem_pools->sized_header_pools);
+ if (interp->mem_pools->attrib_pools)
+ mem_internal_free(interp->mem_pools->attrib_pools);
+ interp->mem_pools->attrib_pools = NULL;
+ interp->mem_pools->sized_header_pools = NULL;
}
/*
-=item C<static int sweep_cb_pmc(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
+=item C<static int sweep_cb_pmc(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+sweep_cb_pmc(PARROT_INTERP, ARGMOD(Fixed_Size_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, Fixed_Size_Obj_Pool *pool, int
+=item C<static int sweep_cb_buf(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool), SHIM(int flag),
+sweep_cb_buf(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool), SHIM(int flag),
ARGIN(void *arg))
{
#ifdef GC_IS_MALLOC
@@ -1105,7 +1105,7 @@
/*
-=item C<static void free_pool(Fixed_Size_Obj_Pool *pool)>
+=item C<static void free_pool(Fixed_Size_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,7 +1115,7 @@
*/
static void
-free_pool(ARGMOD(Fixed_Size_Obj_Pool *pool))
+free_pool(ARGMOD(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(free_pool)
Fixed_Size_Obj_Arena *cur_arena;
@@ -1149,9 +1149,9 @@
int i;
for (i = 0; i < 2; i++) {
- Var_Size_Obj_Pool * const pool = i ?
- interp->arena_base->constant_string_pool :
- interp->arena_base->memory_pool;
+ Variable_Size_Pool * const pool = i ?
+ interp->mem_pools->constant_string_pool :
+ interp->mem_pools->memory_pool;
Memory_Block *cur_block;
cur_block = pool->top_block;
@@ -1182,7 +1182,7 @@
Parrot_gc_ptr_in_memory_pool(PARROT_INTERP, ARGIN(void *bufstart))
{
ASSERT_ARGS(Parrot_gc_ptr_in_memory_pool)
- Var_Size_Obj_Pool * const pool = interp->arena_base->memory_pool;
+ Variable_Size_Pool * const pool = interp->mem_pools->memory_pool;
Memory_Block * cur_block = pool->top_block;
while (cur_block) {
@@ -1210,8 +1210,8 @@
Parrot_gc_ptr_is_pmc(PARROT_INTERP, ARGIN(void *ptr))
{
ASSERT_ARGS(Parrot_gc_ptr_is_pmc)
- return contained_in_pool(interp, interp->arena_base->pmc_pool, ptr) ||
- contained_in_pool(interp, interp->arena_base->constant_pmc_pool, ptr);
+ return contained_in_pool(interp, interp->mem_pools->pmc_pool, ptr) ||
+ contained_in_pool(interp, interp->mem_pools->constant_pmc_pool, ptr);
}
/*
@@ -1231,12 +1231,12 @@
ASSERT_ARGS(Parrot_gc_get_pmc_index)
UINTVAL id = 1; /* first PMC in first arena */
Fixed_Size_Obj_Arena *arena;
- Fixed_Size_Obj_Pool *pool;
+ Fixed_Size_Pool *pool;
if (interp->gc_sys->PObj_to_Arena){
pmc = (PMC*) interp->gc_sys->PObj_to_Arena(pmc);
}
- pool = interp->arena_base->pmc_pool;
+ pool = interp->mem_pools->pmc_pool;
for (arena = pool->last_Arena; arena; arena = arena->prev) {
const ptrdiff_t ptr_diff = (ptrdiff_t)pmc - (ptrdiff_t)arena->start_objects;
if (ptr_diff >= 0 && ptr_diff <
@@ -1248,7 +1248,7 @@
id += arena->total_objects;
}
- pool = interp->arena_base->constant_pmc_pool;
+ pool = interp->mem_pools->constant_pmc_pool;
for (arena = pool->last_Arena; arena; arena = arena->prev) {
const ptrdiff_t ptr_diff = (ptrdiff_t)pmc - (ptrdiff_t)arena->start_objects;
if (ptr_diff >= 0 && ptr_diff <
@@ -1278,13 +1278,13 @@
Parrot_gc_cleanup_next_for_GC(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_cleanup_next_for_GC)
- cleanup_next_for_GC_pool(interp->arena_base->pmc_pool);
- cleanup_next_for_GC_pool(interp->arena_base->constant_pmc_pool);
+ cleanup_next_for_GC_pool(interp->mem_pools->pmc_pool);
+ cleanup_next_for_GC_pool(interp->mem_pools->constant_pmc_pool);
}
/*
-=item C<static void cleanup_next_for_GC_pool(Fixed_Size_Obj_Pool *pool)>
+=item C<static void cleanup_next_for_GC_pool(Fixed_Size_Pool *pool)>
Sets all the C<next_for_GC> pointers to C<NULL>.
@@ -1293,7 +1293,7 @@
*/
static void
-cleanup_next_for_GC_pool(ARGIN(Fixed_Size_Obj_Pool *pool))
+cleanup_next_for_GC_pool(ARGIN(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(cleanup_next_for_GC_pool)
Fixed_Size_Obj_Arena *arena;
@@ -1326,10 +1326,10 @@
{
ASSERT_ARGS(Parrot_gc_active_sized_buffers)
int j, ret = 0;
- const Arenas * const arena_base = interp->arena_base;
- for (j = 0; j < (INTVAL)arena_base->num_sized; j++) {
- Fixed_Size_Obj_Pool * const header_pool =
- arena_base->sized_header_pools[j];
+ const Memory_Pools * const mem_pools = interp->mem_pools;
+ for (j = 0; j < (INTVAL)mem_pools->num_sized; j++) {
+ Fixed_Size_Pool * const header_pool =
+ mem_pools->sized_header_pools[j];
if (header_pool)
ret += header_pool->total_objects -
header_pool->num_free_objects;
@@ -1352,10 +1352,10 @@
{
ASSERT_ARGS(Parrot_gc_total_sized_buffers)
int j, ret = 0;
- const Arenas * const arena_base = interp->arena_base;
- for (j = 0; j < (INTVAL)arena_base->num_sized; j++) {
- Fixed_Size_Obj_Pool * const header_pool =
- arena_base->sized_header_pools[j];
+ const Memory_Pools * const mem_pools = interp->mem_pools;
+ for (j = 0; j < (INTVAL)mem_pools->num_sized; j++) {
+ Fixed_Size_Pool * const header_pool =
+ mem_pools->sized_header_pools[j];
if (header_pool)
ret += header_pool->total_objects;
}
@@ -1376,9 +1376,9 @@
Parrot_gc_active_pmcs(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_active_pmcs)
- const Arenas * const arena_base = interp->arena_base;
- return arena_base->pmc_pool->total_objects -
- arena_base->pmc_pool->num_free_objects;
+ const Memory_Pools * const mem_pools = interp->mem_pools;
+ return mem_pools->pmc_pool->total_objects -
+ mem_pools->pmc_pool->num_free_objects;
}
/*
@@ -1395,8 +1395,8 @@
Parrot_gc_total_pmcs(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_total_pmcs)
- const Arenas * const arena_base = interp->arena_base;
- return arena_base->pmc_pool->total_objects;
+ const Memory_Pools * const mem_pools = interp->mem_pools;
+ return mem_pools->pmc_pool->total_objects;
}
/*
@@ -1437,64 +1437,64 @@
Parrot_gc_count_mark_runs(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_count_mark_runs)
- const Arenas * const arena_base = interp->arena_base;
- return arena_base->gc_mark_runs;
+ const Memory_Pools * const mem_pools = interp->mem_pools;
+ return mem_pools->gc_mark_runs;
}
size_t
Parrot_gc_count_collect_runs(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_count_collect_runs)
- const Arenas * const arena_base = interp->arena_base;
- return arena_base->gc_collect_runs;
+ const Memory_Pools * const mem_pools = interp->mem_pools;
+ return mem_pools->gc_collect_runs;
}
size_t
Parrot_gc_count_lazy_mark_runs(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_count_lazy_mark_runs)
- const Arenas * const arena_base = interp->arena_base;
- return arena_base->gc_lazy_mark_runs;;
+ const Memory_Pools * const mem_pools = interp->mem_pools;
+ return mem_pools->gc_lazy_mark_runs;;
}
size_t
Parrot_gc_total_memory_allocated(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_total_memory_allocated)
- const Arenas * const arena_base = interp->arena_base;
- return arena_base->memory_allocated;
+ const Memory_Pools * const mem_pools = interp->mem_pools;
+ return mem_pools->memory_allocated;
}
size_t
Parrot_gc_headers_alloc_since_last_collect(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_headers_alloc_since_last_collect)
- const Arenas * const arena_base = interp->arena_base;
- return arena_base->header_allocs_since_last_collect;
+ const Memory_Pools * const mem_pools = interp->mem_pools;
+ return mem_pools->header_allocs_since_last_collect;
}
size_t
Parrot_gc_mem_alloc_since_last_collect(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_mem_alloc_since_last_collect)
- const Arenas * const arena_base = interp->arena_base;
- return arena_base->mem_allocs_since_last_collect;
+ const Memory_Pools * const mem_pools = interp->mem_pools;
+ return mem_pools->mem_allocs_since_last_collect;
}
UINTVAL
Parrot_gc_total_copied(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_total_copied)
- const Arenas * const arena_base = interp->arena_base;
- return arena_base->memory_collected;
+ const Memory_Pools * const mem_pools = interp->mem_pools;
+ return mem_pools->memory_collected;
}
UINTVAL
Parrot_gc_impatient_pmcs(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_impatient_pmcs)
- const Arenas * const arena_base = interp->arena_base;
- return arena_base->num_early_gc_PMCs;
+ const Memory_Pools * const mem_pools = interp->mem_pools;
+ return mem_pools->num_early_gc_PMCs;
}
/*
@@ -1537,7 +1537,7 @@
Parrot_block_GC_mark(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_block_GC_mark)
- interp->arena_base->gc_mark_block_level++;
+ interp->mem_pools->gc_mark_block_level++;
Parrot_shared_gc_block(interp);
}
@@ -1546,8 +1546,8 @@
Parrot_unblock_GC_mark(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_unblock_GC_mark)
- if (interp->arena_base->gc_mark_block_level) {
- interp->arena_base->gc_mark_block_level--;
+ if (interp->mem_pools->gc_mark_block_level) {
+ interp->mem_pools->gc_mark_block_level--;
Parrot_shared_gc_unblock(interp);
}
}
@@ -1557,7 +1557,7 @@
Parrot_block_GC_sweep(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_block_GC_sweep)
- interp->arena_base->gc_sweep_block_level++;
+ interp->mem_pools->gc_sweep_block_level++;
}
PARROT_EXPORT
@@ -1565,8 +1565,8 @@
Parrot_unblock_GC_sweep(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_unblock_GC_sweep)
- if (interp->arena_base->gc_sweep_block_level)
- interp->arena_base->gc_sweep_block_level--;
+ if (interp->mem_pools->gc_sweep_block_level)
+ interp->mem_pools->gc_sweep_block_level--;
}
PARROT_EXPORT
@@ -1574,7 +1574,7 @@
Parrot_is_blocked_GC_mark(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_is_blocked_GC_mark)
- return interp->arena_base->gc_mark_block_level;
+ return interp->mem_pools->gc_mark_block_level;
}
PARROT_EXPORT
@@ -1582,15 +1582,15 @@
Parrot_is_blocked_GC_sweep(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_is_blocked_GC_sweep)
- return interp->arena_base->gc_sweep_block_level;
+ return interp->mem_pools->gc_sweep_block_level;
}
void
Parrot_gc_completely_unblock(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_completely_unblock)
- interp->arena_base->gc_mark_block_level = 0;
- interp->arena_base->gc_sweep_block_level = 0;
+ interp->mem_pools->gc_mark_block_level = 0;
+ interp->mem_pools->gc_sweep_block_level = 0;
}
/*
@@ -1608,7 +1608,7 @@
{
ASSERT_ARGS(Parrot_gc_pmc_needs_early_collection)
PObj_needs_early_gc_SET(pmc);
- ++interp->arena_base->num_early_gc_PMCs;
+ ++interp->mem_pools->num_early_gc_PMCs;
}
/*
@@ -1689,7 +1689,7 @@
void * const data = PMC_data(pmc);
if (data) {
- PMC_Attribute_Pool **pools = interp->arena_base->attrib_pools;
+ PMC_Attribute_Pool **pools = interp->mem_pools->attrib_pools;
const size_t idx = item_size - sizeof (void *);
PMC_Attribute_Pool * const pool = pools[idx];
Parrot_gc_free_attributes_from_pool(interp, pool, data);
@@ -1729,7 +1729,7 @@
Parrot_gc_free_fixed_size_storage(PARROT_INTERP, size_t size, ARGMOD(void *data))
{
ASSERT_ARGS(Parrot_gc_free_fixed_size_storage)
- PMC_Attribute_Pool **pools = interp->arena_base->attrib_pools;
+ PMC_Attribute_Pool **pools = interp->mem_pools->attrib_pools;
const size_t idx = size - sizeof (void *);
PMC_Attribute_Pool * const pool = pools[idx];
Modified: branches/gc-refactor/src/gc/gc_inf.c
==============================================================================
--- branches/gc-refactor/src/gc/gc_inf.c Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/src/gc/gc_inf.c Mon Sep 7 01:02:27 2009 (r41088)
@@ -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(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Pool *pool),
ARGIN(void *to_add))
__attribute__nonnull__(2)
__attribute__nonnull__(3)
FUNC_MODIFIES(*pool);
static void gc_inf_alloc_objects(SHIM_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool))
+ ARGMOD(Fixed_Size_Pool *pool))
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
PARROT_CANNOT_RETURN_NULL
static void * gc_inf_get_free_object(SHIM_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool))
+ ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool))
+ ARGMOD(Fixed_Size_Pool *pool))
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
-static void gc_inf_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
+static void gc_inf_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Pool *pool))
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
@@ -112,7 +112,7 @@
/*
-=item C<static void gc_inf_add_free_object(PARROT_INTERP, Fixed_Size_Obj_Pool
+=item C<static void gc_inf_add_free_object(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+gc_inf_add_free_object(SHIM_INTERP, ARGMOD(Fixed_Size_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, Fixed_Size_Obj_Pool
+=item C<static void * gc_inf_get_free_object(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool))
+gc_inf_get_free_object(SHIM_INTERP, ARGMOD(Fixed_Size_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, Fixed_Size_Obj_Pool
+=item C<static void gc_inf_alloc_objects(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool))
+gc_inf_alloc_objects(SHIM_INTERP, ARGMOD(Fixed_Size_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,
-Fixed_Size_Obj_Pool *pool)>
+Fixed_Size_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(Fixed_Size_Obj_Pool *pool))
+gc_inf_more_traceable_objects(SHIM_INTERP, ARGMOD(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(gc_inf_more_traceable_objects)
UNUSED(pool);
@@ -216,14 +216,14 @@
/*
-=item C<static void gc_inf_pool_init(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
+=item C<static void gc_inf_pool_init(PARROT_INTERP, Fixed_Size_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.
In this way we can treat different pools differently if they have special
management needs. In general all PObj-like pools are treated the same.
-This function is mostly called from the function C<initialize_header_pools>
+This function is mostly called from the function C<initialize_fixed_size_pools>
in F<src/gc/mark_sweep.c> at Parrot startup.
=cut
@@ -231,7 +231,7 @@
*/
static void
-gc_inf_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
+gc_inf_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(gc_inf_pool_init)
pool->add_free_object = gc_inf_add_free_object;
@@ -245,7 +245,7 @@
=item C<void Parrot_gc_inf_init(PARROT_INTERP)>
Initializes the infinite memory collector. Installs the necessary function
-pointers into the Arenas structure. The two most important are the
+pointers into the Memory_Pools structure. The two most important are the
C<mark_and_sweep> and C<pool_init> functions. C<finalize_gc_system> function
will be called at Parrot exit and will shut down the GC system if things
need to be flushed/closed/deactivated/freed/etc. It can be set to NULL if no
Modified: branches/gc-refactor/src/gc/gc_malloc.c
==============================================================================
--- branches/gc-refactor/src/gc/gc_malloc.c Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/src/gc/gc_malloc.c Mon Sep 7 01:02:27 2009 (r41088)
@@ -28,14 +28,14 @@
/* Don't modify between HEADERIZER BEGIN / HEADERIZER END. Your changes will be lost. */
static void clear_cow(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Pool *pool),
int cleanup)
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
static int sweep_cb(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Pool *pool),
int flag,
ARGMOD(void *arg))
__attribute__nonnull__(1)
@@ -45,7 +45,7 @@
FUNC_MODIFIES(*arg);
static void used_cow(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Pool *pool),
int cleanup)
__attribute__nonnull__(1)
__attribute__nonnull__(2)
@@ -58,7 +58,7 @@
/*
-=item C<static int sweep_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int flag, void *arg)>
+=item C<static int sweep_cb(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool), int flag,
+sweep_cb(PARROT_INTERP, ARGMOD(Fixed_Size_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, Fixed_Size_Obj_Pool *pool, int cleanup)>
+=item C<static void clear_cow(PARROT_INTERP, Fixed_Size_Pool *pool, int cleanup)>
Clears the COW ref count.
@@ -102,7 +102,7 @@
*/
static void
-clear_cow(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), int cleanup)
+clear_cow(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool), int cleanup)
{
const UINTVAL object_size = pool->object_size;
Fixed_Size_Obj_Arena *cur_arena;
@@ -139,7 +139,7 @@
/*
-=item C<static void used_cow(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int cleanup)>
+=item C<static void used_cow(PARROT_INTERP, Fixed_Size_Pool *pool, int cleanup)>
Finds other users of COW's C<bufstart>.
@@ -148,7 +148,7 @@
*/
static void
-used_cow(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), int cleanup)
+used_cow(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool), int cleanup)
{
const UINTVAL object_size = pool->object_size;
Fixed_Size_Obj_Arena *cur_arena;
Modified: branches/gc-refactor/src/gc/gc_ms.c
==============================================================================
--- branches/gc-refactor/src/gc/gc_ms.c Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/src/gc/gc_ms.c Mon Sep 7 01:02:27 2009 (r41088)
@@ -23,26 +23,26 @@
/* Don't modify between HEADERIZER BEGIN / HEADERIZER END. Your changes will be lost. */
static void gc_ms_add_free_object(SHIM_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Pool *pool),
ARGIN(void *to_add))
__attribute__nonnull__(2)
__attribute__nonnull__(3)
FUNC_MODIFIES(*pool);
static void gc_ms_alloc_objects(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool))
+ ARGMOD(Fixed_Size_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
-static void gc_ms_finalize(PARROT_INTERP, ARGIN(Arenas * const arena_base))
+static void gc_ms_finalize(PARROT_INTERP, ARGIN(Memory_Pools * const mem_pools))
__attribute__nonnull__(1)
__attribute__nonnull__(2);
PARROT_CANNOT_RETURN_NULL
PARROT_WARN_UNUSED_RESULT
static void * gc_ms_get_free_object(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool))
+ ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool))
+ ARGMOD(Fixed_Size_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
-static void gc_ms_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
+static void gc_ms_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Pool *pool))
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
static int gc_ms_sweep_cb(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Pool *pool),
int flag,
ARGMOD(void *arg))
__attribute__nonnull__(1)
@@ -82,7 +82,7 @@
|| PARROT_ASSERT_ARG(pool)
#define ASSERT_ARGS_gc_ms_finalize __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(interp) \
- || PARROT_ASSERT_ARG(arena_base)
+ || PARROT_ASSERT_ARG(mem_pools)
#define ASSERT_ARGS_gc_ms_get_free_object __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(interp) \
|| PARROT_ASSERT_ARG(pool)
@@ -144,25 +144,25 @@
gc_ms_mark_and_sweep(PARROT_INTERP, UINTVAL flags)
{
ASSERT_ARGS(gc_ms_mark_and_sweep)
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
int total_free = 0;
- if (arena_base->gc_mark_block_level)
+ if (mem_pools->gc_mark_block_level)
return;
if (interp->pdb && interp->pdb->debugger) {
/* The debugger could have performed a mark. Make sure everything is
marked dead here, so that when we sweep it all gets collected */
- Parrot_gc_clear_live_bits(interp, arena_base->pmc_pool);
+ Parrot_gc_clear_live_bits(interp, mem_pools->pmc_pool);
}
if (flags & GC_finish_FLAG) {
- gc_ms_finalize(interp, arena_base);
+ gc_ms_finalize(interp, mem_pools);
return;
}
- ++arena_base->gc_mark_block_level;
- arena_base->lazy_gc = flags & GC_lazy_FLAG;
+ ++mem_pools->gc_mark_block_level;
+ mem_pools->lazy_gc = flags & GC_lazy_FLAG;
/* tell the threading system that we're doing GC mark */
pt_gc_start_mark(interp);
@@ -176,8 +176,8 @@
if (gc_ms_trace_active_PMCs(interp, (flags & GC_trace_stack_FLAG)
? GC_TRACE_FULL : GC_TRACE_ROOT_ONLY)) {
- arena_base->gc_trace_ptr = NULL;
- arena_base->gc_mark_ptr = NULL;
+ mem_pools->gc_trace_ptr = NULL;
+ mem_pools->gc_mark_ptr = NULL;
/* We've done the mark, now do the sweep. Pass the sweep callback
function to the PMC pool and all the sized pools. */
@@ -188,9 +188,9 @@
Parrot_gc_profile_end(interp, PARROT_PROF_GC_cb);
}
else {
- ++arena_base->gc_lazy_mark_runs;
+ ++mem_pools->gc_lazy_mark_runs;
- Parrot_gc_clear_live_bits(interp, arena_base->pmc_pool);
+ Parrot_gc_clear_live_bits(interp, mem_pools->pmc_pool);
if (interp->profile)
Parrot_gc_profile_end(interp, PARROT_PROF_GC_p2);
}
@@ -198,15 +198,15 @@
pt_gc_stop_mark(interp);
/* Note it */
- arena_base->gc_mark_runs++;
- --arena_base->gc_mark_block_level;
+ mem_pools->gc_mark_runs++;
+ --mem_pools->gc_mark_block_level;
return;
}
/*
-=item C<static void gc_ms_finalize(PARROT_INTERP, Arenas * const arena_base)>
+=item C<static void gc_ms_finalize(PARROT_INTERP, Memory_Pools * const mem_pools)>
Perform the finalization run, freeing all PMCs.
@@ -215,23 +215,23 @@
*/
static void
-gc_ms_finalize(PARROT_INTERP, ARGIN(Arenas * const arena_base))
+gc_ms_finalize(PARROT_INTERP, ARGIN(Memory_Pools * const mem_pools))
{
ASSERT_ARGS(gc_ms_finalize)
- Parrot_gc_clear_live_bits(interp, arena_base->pmc_pool);
- Parrot_gc_clear_live_bits(interp, arena_base->constant_pmc_pool);
+ Parrot_gc_clear_live_bits(interp, mem_pools->pmc_pool);
+ Parrot_gc_clear_live_bits(interp, mem_pools->constant_pmc_pool);
/* keep the scheduler and its kids alive for Task-like PMCs to destroy
* themselves; run a sweep to collect them */
if (interp->scheduler) {
Parrot_gc_mark_PObj_alive(interp, (PObj *)interp->scheduler);
VTABLE_mark(interp, interp->scheduler);
- Parrot_gc_sweep_pool(interp, interp->arena_base->pmc_pool);
+ Parrot_gc_sweep_pool(interp, interp->mem_pools->pmc_pool);
}
/* now sweep everything that's left */
- Parrot_gc_sweep_pool(interp, interp->arena_base->pmc_pool);
- Parrot_gc_sweep_pool(interp, interp->arena_base->constant_pmc_pool);
+ Parrot_gc_sweep_pool(interp, interp->mem_pools->pmc_pool);
+ Parrot_gc_sweep_pool(interp, interp->mem_pools->constant_pmc_pool);
}
@@ -262,7 +262,7 @@
/*
-=item C<static int gc_ms_sweep_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
+=item C<static int gc_ms_sweep_cb(PARROT_INTERP, Fixed_Size_Pool *pool, int
flag, void *arg)>
Sweeps the given pool for the MS collector. This function also ends
@@ -274,7 +274,7 @@
*/
static int
-gc_ms_sweep_cb(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), int flag,
+gc_ms_sweep_cb(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool), int flag,
ARGMOD(void *arg))
{
ASSERT_ARGS(gc_ms_sweep_cb)
@@ -298,7 +298,7 @@
=over 4
-=item C<static void gc_ms_pool_init(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
+=item C<static void gc_ms_pool_init(PARROT_INTERP, Fixed_Size_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
@@ -309,7 +309,7 @@
*/
static void
-gc_ms_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
+gc_ms_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(gc_ms_pool_init)
pool->add_free_object = gc_ms_add_free_object;
@@ -321,7 +321,7 @@
/*
=item C<static void gc_ms_more_traceable_objects(PARROT_INTERP,
-Fixed_Size_Obj_Pool *pool)>
+Fixed_Size_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.
@@ -331,7 +331,7 @@
*/
static void
-gc_ms_more_traceable_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
+gc_ms_more_traceable_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(gc_ms_more_traceable_objects)
@@ -358,7 +358,7 @@
/*
-=item C<static void gc_ms_add_free_object(PARROT_INTERP, Fixed_Size_Obj_Pool
+=item C<static void gc_ms_add_free_object(PARROT_INTERP, Fixed_Size_Pool
*pool, void *to_add)>
Add an unused object back to the pool's free list for later reuse. Set
@@ -369,7 +369,7 @@
*/
static void
-gc_ms_add_free_object(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool),
+gc_ms_add_free_object(SHIM_INTERP, ARGMOD(Fixed_Size_Pool *pool),
ARGIN(void *to_add))
{
ASSERT_ARGS(gc_ms_add_free_object)
@@ -383,7 +383,7 @@
/*
-=item C<static void * gc_ms_get_free_object(PARROT_INTERP, Fixed_Size_Obj_Pool
+=item C<static void * gc_ms_get_free_object(PARROT_INTERP, Fixed_Size_Pool
*pool)>
Free object allocator for the MS garbage collector system. If there are no
@@ -398,7 +398,7 @@
PARROT_CANNOT_RETURN_NULL
PARROT_WARN_UNUSED_RESULT
static void *
-gc_ms_get_free_object(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
+gc_ms_get_free_object(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(gc_ms_get_free_object)
PObj *ptr;
@@ -447,7 +447,7 @@
/*
-=item C<static void gc_ms_alloc_objects(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
+=item C<static void gc_ms_alloc_objects(PARROT_INTERP, Fixed_Size_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
@@ -458,7 +458,7 @@
*/
static void
-gc_ms_alloc_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
+gc_ms_alloc_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(gc_ms_alloc_objects)
/* Setup memory for the new objects */
Modified: branches/gc-refactor/src/gc/gc_private.h
==============================================================================
--- branches/gc-refactor/src/gc/gc_private.h Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/src/gc/gc_private.h Mon Sep 7 01:02:27 2009 (r41088)
@@ -102,7 +102,7 @@
/** Function hooks that each subsystem MUST provide */
void (*do_gc_mark)(PARROT_INTERP, UINTVAL flags);
void (*finalize_gc_system) (PARROT_INTERP);
- void (*init_pool)(PARROT_INTERP, struct Fixed_Size_Obj_Pool *);
+ void (*init_pool)(PARROT_INTERP, struct Fixed_Size_Pool *);
/*Function hooks that GC systems can CHOOSE to provide if they need them
*These will be called from the GC API function Parrot_gc_func_name */
@@ -128,16 +128,16 @@
char *top;
} Memory_Block;
-typedef struct Var_Size_Obj_Pool {
+typedef struct Variable_Size_Pool {
Memory_Block *top_block;
- void (*compact)(PARROT_INTERP, struct Var_Size_Obj_Pool *);
+ void (*compact)(PARROT_INTERP, struct Variable_Size_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 */
-} Var_Size_Obj_Pool;
+} Variable_Size_Pool;
typedef struct Fixed_Size_Obj_Arena {
size_t used;
@@ -170,9 +170,9 @@
} PMC_Attribute_Pool;
/* Tracked resource pool */
-typedef struct Fixed_Size_Obj_Pool {
+typedef struct Fixed_Size_Pool {
- struct Var_Size_Obj_Pool *mem_pool;
+ struct Variable_Size_Pool *mem_pool;
/* Size in bytes of an individual pool item. This size may include
* a GC-system specific GC header. (e.g. GMS headers) */
size_t object_size;
@@ -211,16 +211,16 @@
void *newlast;
#endif
-} Fixed_Size_Obj_Pool;
+} Fixed_Size_Pool;
-typedef struct Arenas {
- 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;
+typedef struct Memory_Pools {
+ Variable_Size_Pool *memory_pool;
+ Variable_Size_Pool *constant_string_pool;
+ struct Fixed_Size_Pool *string_header_pool;
+ struct Fixed_Size_Pool *pmc_pool;
+ struct Fixed_Size_Pool *constant_pmc_pool;
+ struct Fixed_Size_Pool *constant_string_header_pool;
+ struct Fixed_Size_Pool **sized_header_pools;
size_t num_sized;
PMC_Attribute_Pool **attrib_pools;
@@ -266,7 +266,7 @@
* private data for the GC subsystem
*/
void * gc_private; /* gc subsystem data */
-} Arenas;
+} Memory_Pools;
/* HEADERIZER BEGIN: src/gc/system.c */
@@ -364,7 +364,7 @@
PARROT_WARN_UNUSED_RESULT
INTVAL contained_in_pool(PARROT_INTERP,
- ARGIN(const Fixed_Size_Obj_Pool *pool),
+ ARGIN(const Fixed_Size_Pool *pool),
ARGIN(const void *ptr))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
@@ -372,7 +372,7 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-Fixed_Size_Obj_Pool * get_bufferlike_pool(PARROT_INTERP, size_t buffer_size)
+Fixed_Size_Pool * get_bufferlike_pool(PARROT_INTERP, size_t buffer_size)
__attribute__nonnull__(1);
PARROT_IGNORABLE_RESULT
@@ -384,7 +384,7 @@
__attribute__nonnull__(1)
__attribute__nonnull__(4);
-void initialize_header_pools(PARROT_INTERP)
+void initialize_fixed_size_pools(PARROT_INTERP)
__attribute__nonnull__(1);
void mark_special(PARROT_INTERP, ARGIN(PMC *obj))
@@ -392,7 +392,7 @@
__attribute__nonnull__(2);
void Parrot_add_to_free_list(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Pool *pool),
ARGMOD(Fixed_Size_Obj_Arena *arena))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
@@ -401,7 +401,7 @@
FUNC_MODIFIES(*arena);
void Parrot_append_arena_in_pool(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Pool *pool),
ARGMOD(Fixed_Size_Obj_Arena *new_arena),
size_t size)
__attribute__nonnull__(1)
@@ -411,7 +411,7 @@
FUNC_MODIFIES(*new_arena);
void Parrot_gc_clear_live_bits(PARROT_INTERP,
- ARGIN(const Fixed_Size_Obj_Pool *pool))
+ ARGIN(const Fixed_Size_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2);
@@ -445,7 +445,7 @@
void Parrot_gc_run_init(PARROT_INTERP)
__attribute__nonnull__(1);
-void Parrot_gc_sweep_pool(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
+void Parrot_gc_sweep_pool(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
@@ -465,7 +465,7 @@
#define ASSERT_ARGS_header_pools_iterate_callback __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(interp) \
|| PARROT_ASSERT_ARG(func)
-#define ASSERT_ARGS_initialize_header_pools __attribute__unused__ int _ASSERT_ARGS_CHECK = \
+#define ASSERT_ARGS_initialize_fixed_size_pools __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(interp)
#define ASSERT_ARGS_mark_special __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(interp) \
@@ -513,7 +513,7 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-Fixed_Size_Obj_Pool * get_bufferlike_pool(PARROT_INTERP, size_t buffer_size)
+Fixed_Size_Pool * get_bufferlike_pool(PARROT_INTERP, size_t buffer_size)
__attribute__nonnull__(1);
PARROT_IGNORABLE_RESULT
@@ -525,7 +525,7 @@
__attribute__nonnull__(1)
__attribute__nonnull__(4);
-void initialize_header_pools(PARROT_INTERP)
+void initialize_fixed_size_pools(PARROT_INTERP)
__attribute__nonnull__(1);
#define ASSERT_ARGS_get_bufferlike_pool __attribute__unused__ int _ASSERT_ARGS_CHECK = \
@@ -533,7 +533,7 @@
#define ASSERT_ARGS_header_pools_iterate_callback __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(interp) \
|| PARROT_ASSERT_ARG(func)
-#define ASSERT_ARGS_initialize_header_pools __attribute__unused__ int _ASSERT_ARGS_CHECK = \
+#define ASSERT_ARGS_initialize_fixed_size_pools __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(interp)
/* Don't modify between HEADERIZER BEGIN / HEADERIZER END. Your changes will be lost. */
/* HEADERIZER END: src/gc/pools.c */
@@ -556,28 +556,28 @@
PARROT_WARN_UNUSED_RESULT
size_t aligned_string_size(size_t len);
-void check_buffer_ptr(ARGMOD(Buffer * pobj), ARGMOD(Var_Size_Obj_Pool * pool))
+void check_buffer_ptr(ARGMOD(Buffer * pobj), ARGMOD(Variable_Size_Pool * pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(* pobj)
FUNC_MODIFIES(* pool);
-void compact_pool(PARROT_INTERP, ARGMOD(Var_Size_Obj_Pool *pool))
+void compact_pool(PARROT_INTERP, ARGMOD(Variable_Size_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
-void initialize_memory_pools(PARROT_INTERP)
+void initialize_var_size_pools(PARROT_INTERP)
__attribute__nonnull__(1);
PARROT_MALLOC
PARROT_CANNOT_RETURN_NULL
-void * mem_allocate(PARROT_INTERP, size_t size, ARGMOD(Var_Size_Obj_Pool *pool))
+void * mem_allocate(PARROT_INTERP, size_t size, ARGMOD(Variable_Size_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(3)
FUNC_MODIFIES(*pool);
-void merge_pools(ARGMOD(Var_Size_Obj_Pool *dest), ARGMOD(Var_Size_Obj_Pool *source))
+void merge_pools(ARGMOD(Variable_Size_Pool *dest), ARGMOD(Variable_Size_Pool *source))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*dest)
@@ -595,7 +595,7 @@
#define ASSERT_ARGS_compact_pool __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(interp) \
|| PARROT_ASSERT_ARG(pool)
-#define ASSERT_ARGS_initialize_memory_pools __attribute__unused__ int _ASSERT_ARGS_CHECK = \
+#define ASSERT_ARGS_initialize_var_size_pools __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(interp)
#define ASSERT_ARGS_mem_allocate __attribute__unused__ int _ASSERT_ARGS_CHECK = \
PARROT_ASSERT_ARG(interp) \
Modified: branches/gc-refactor/src/gc/generational_ms.c
==============================================================================
--- branches/gc-refactor/src/gc/generational_ms.c Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/src/gc/generational_ms.c Mon Sep 7 01:02:27 2009 (r41088)
@@ -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(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Pool *pool),
int flag,
SHIM(void *arg))
__attribute__nonnull__(1)
@@ -133,18 +133,18 @@
FUNC_MODIFIES(*pool);
static void gc_gms_add_free_object(PARROT_INTERP,
- SHIM(Fixed_Size_Obj_Pool *pool),
+ SHIM(Fixed_Size_Pool *pool),
SHIM(PObj *to_add))
__attribute__nonnull__(1);
static void gc_gms_alloc_objects(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool))
+ ARGMOD(Fixed_Size_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
static void gc_gms_chain_objects(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Pool *pool),
ARGIN(Fixed_Size_Obj_Arena *new_arena),
size_t real_size)
__attribute__nonnull__(1)
@@ -164,7 +164,7 @@
PARROT_MALLOC
PARROT_CANNOT_RETURN_NULL
static Gc_gms_gen * gc_gms_create_gen(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool))
+ ARGMOD(Fixed_Size_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
-static void gc_gms_init_gen(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
+static void gc_gms_init_gen(PARROT_INTERP, ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool))
+ ARGMOD(Fixed_Size_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
-static void gc_gms_pool_init(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
+static void gc_gms_pool_init(PARROT_INTERP, ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+ ARGIN(Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+ ARGIN(Fixed_Size_Pool *pool),
int flag,
SHIM(void *arg))
__attribute__nonnull__(1)
__attribute__nonnull__(2);
static int trace_children_cb(PARROT_INTERP,
- ARGIN(Fixed_Size_Obj_Pool *pool),
+ ARGIN(Fixed_Size_Pool *pool),
int flag,
SHIM(void *arg))
__attribute__nonnull__(1)
__attribute__nonnull__(2);
static int trace_igp_cb(PARROT_INTERP,
- ARGIN(Fixed_Size_Obj_Pool *pool),
+ ARGIN(Fixed_Size_Pool *pool),
int flag,
SHIM(void *arg))
__attribute__nonnull__(1)
@@ -509,18 +509,18 @@
parrot_gc_gms_deinit(PARROT_INTERP)
{
ASSERT_ARGS(parrot_gc_gms_deinit)
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
/*
* TODO free generations
*/
- mem_sys_free(arena_base->gc_private);
- arena_base->gc_private = NULL;
+ mem_sys_free(mem_pools->gc_private);
+ mem_pools->gc_private = NULL;
}
/*
-=item C<static void gc_gms_pool_init(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
+=item C<static void gc_gms_pool_init(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool))
+gc_gms_pool_init(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(gc_gms_pool_init)
pool->add_free_object = gc_gms_add_free_object;
@@ -562,9 +562,9 @@
Parrot_gc_gms_init(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_gms_init)
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
- arena_base->gc_private = mem_sys_allocate_zeroed(sizeof (Gc_gms_private));
+ mem_pools->gc_private = mem_sys_allocate_zeroed(sizeof (Gc_gms_private));
/*
* set function hooks according to pdd09
@@ -583,7 +583,7 @@
=over 4
-=item C<static void gc_gms_add_free_object(PARROT_INTERP, Fixed_Size_Obj_Pool
+=item C<static void gc_gms_add_free_object(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+gc_gms_add_free_object(PARROT_INTERP, SHIM(Fixed_Size_Pool *pool),
SHIM(PObj *to_add))
{
ASSERT_ARGS(gc_gms_add_free_object)
@@ -603,7 +603,7 @@
/*
-=item C<static void gc_gms_chain_objects(PARROT_INTERP, Fixed_Size_Obj_Pool *pool,
+=item C<static void gc_gms_chain_objects(PARROT_INTERP, Fixed_Size_Pool *pool,
Fixed_Size_Obj_Arena *new_arena, size_t real_size)>
TODO: interfere custom_destroy and put these items into a
@@ -644,7 +644,7 @@
*/
static void
-gc_gms_chain_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool),
+gc_gms_chain_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool),
ARGIN(Fixed_Size_Obj_Arena *new_arena), size_t real_size)
{
ASSERT_ARGS(gc_gms_chain_objects)
@@ -694,7 +694,7 @@
/*
-=item C<static void gc_gms_alloc_objects(PARROT_INTERP, Fixed_Size_Obj_Pool
+=item C<static void gc_gms_alloc_objects(PARROT_INTERP, Fixed_Size_Pool
*pool)>
Allocate new objects for the given pool.
@@ -704,7 +704,7 @@
*/
static void
-gc_gms_alloc_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
+gc_gms_alloc_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(gc_gms_alloc_objects)
const size_t real_size = pool->object_size;
@@ -728,7 +728,7 @@
/*
-=item C<static void gc_gms_more_objects(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
+=item C<static void gc_gms_more_objects(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool))
+gc_gms_more_objects(PARROT_INTERP, ARGMOD(Fixed_Size_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, Fixed_Size_Obj_Pool
+=item C<static PObj * gc_gms_get_free_object(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool))
+gc_gms_get_free_object(PARROT_INTERP, ARGMOD(Fixed_Size_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, Fixed_Size_Obj_Pool
+=item C<static Gc_gms_gen * gc_gms_create_gen(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool), size_t gen_no)
+gc_gms_create_gen(PARROT_INTERP, ARGMOD(Fixed_Size_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, Fixed_Size_Obj_Pool *pool)>
+=item C<static void gc_gms_init_gen(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool))
+gc_gms_init_gen(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(gc_gms_init_gen)
Gc_gms_private *gmsp;
@@ -868,7 +868,7 @@
*/
pool->first_gen = gc_gms_create_gen(interp, pool, 0);
pool->last_gen = pool->first_gen;
- gmsp = interp->arena_base->gc_private;
+ gmsp = interp->mem_pools->gc_private;
gmsp->current_gen_no = 0;
}
@@ -890,7 +890,7 @@
{
ASSERT_ARGS(gc_gms_find_gen)
Gc_gms_gen *gen;
- const Fixed_Size_Obj_Pool * const pool = h->gen->pool;
+ const Fixed_Size_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;
- Fixed_Size_Obj_Pool * const pool = h->gen->pool;
+ Fixed_Size_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, Fixed_Size_Obj_Pool *pool, int
+=item C<static void gc_gms_merge_gen(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+gc_gms_merge_gen(PARROT_INTERP, ARGMOD(Fixed_Size_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, Fixed_Size_Obj_Pool *pool, int
+=item C<static void gc_gms_use_gen(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+gc_gms_use_gen(PARROT_INTERP, ARGMOD(Fixed_Size_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, Fixed_Size_Obj_Pool *pool, int flag,
+=item C<static int set_gen_cb(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool), int flag, ARGIN(void *arg))
+set_gen_cb(PARROT_INTERP, ARGIN(Fixed_Size_Pool *pool), int flag, ARGIN(void *arg))
{
ASSERT_ARGS(set_gen_cb)
Gc_gms_plan * const plan = (Gc_gms_plan *)arg;
@@ -1262,7 +1262,7 @@
* 3) and 4) need to reset live flags of the previous generation(s)
* or better use the per-generation black_color for marking
*/
- gmsp = interp->arena_base->gc_private;
+ gmsp = interp->mem_pools->gc_private;
plan.merge_gen = 0;
plan.gen_no = gmsp->current_gen_no;
if (gmsp->current_gen_no > 0)
@@ -1360,7 +1360,7 @@
gc_gms_setto_gray(PARROT_INTERP, ARGIN(Gc_gms_hdr *h), int priority)
{
ASSERT_ARGS(gc_gms_setto_gray)
- Fixed_Size_Obj_Pool * const pool = h->gen->pool;
+ Fixed_Size_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)
- Fixed_Size_Obj_Pool * const pool = h->gen->pool;
+ Fixed_Size_Pool * const pool = h->gen->pool;
/*
* TODO high_priority like src/gc/api.c
@@ -1491,7 +1491,7 @@
PObj_live_SET(obj);
priority = PObj_needs_early_gc_TEST(obj);
if (priority)
- ++interp->arena_base->num_early_PMCs_seen;
+ ++interp->mem_pools->num_early_PMCs_seen;
h = PObj_to_GMSH(obj);
/* unsnap it from white, put it into gray or black */
if (PObj_is_PMC_TEST(obj))
@@ -1502,7 +1502,7 @@
/*
-=item C<static int init_mark_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
+=item C<static int init_mark_cb(PARROT_INTERP, Fixed_Size_Pool *pool, int
flag, void *arg)>
Initialization callback, initialize all the pointers.
@@ -1512,7 +1512,7 @@
*/
static int
-init_mark_cb(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), int flag, ARGIN(void *arg))
+init_mark_cb(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool), int flag, ARGIN(void *arg))
{
ASSERT_ARGS(init_mark_cb)
pool->gray = pool->black = pool->black_fin = pool->white;
@@ -1536,19 +1536,19 @@
gc_gms_init_mark(PARROT_INTERP)
{
ASSERT_ARGS(gc_gms_init_mark)
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
- arena_base->gc_trace_ptr = NULL;
- arena_base->gc_mark_start = NULL;
- arena_base->num_early_PMCs_seen = 0;
- arena_base->num_extended_PMCs = 0;
+ mem_pools->gc_trace_ptr = NULL;
+ mem_pools->gc_mark_start = NULL;
+ mem_pools->num_early_PMCs_seen = 0;
+ mem_pools->num_extended_PMCs = 0;
header_pools_iterate_callback(interp, POOL_ALL, 0, init_mark_cb);
}
/*
-=item C<static int trace_igp_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
+=item C<static int trace_igp_cb(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool), int flag, SHIM(void *arg))
+trace_igp_cb(PARROT_INTERP, ARGIN(Fixed_Size_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, Fixed_Size_Obj_Pool *pool, int
+=item C<static int trace_children_cb(PARROT_INTERP, Fixed_Size_Pool *pool, int
flag, void *arg)>
Trace through child objects
@@ -1610,23 +1610,23 @@
*/
static int
-trace_children_cb(PARROT_INTERP, ARGIN(Fixed_Size_Obj_Pool *pool), int flag, SHIM(void *arg))
+trace_children_cb(PARROT_INTERP, ARGIN(Fixed_Size_Pool *pool), int flag, SHIM(void *arg))
{
ASSERT_ARGS(trace_children_cb)
- Arenas * const arena_base = interp->arena_base;
- const int lazy_gc = arena_base->lazy_gc;
+ Memory_Pools * const mem_pools = interp->mem_pools;
+ const int lazy_gc = mem_pools->lazy_gc;
Gc_gms_hdr *h;
for (h = pool->gray; h != pool->white;) {
PMC * const current = (PMC*)GMSH_to_PObj(h);
UINTVAL bits;
- if (lazy_gc && arena_base->num_early_PMCs_seen >=
- arena_base->num_early_gc_PMCs) {
+ if (lazy_gc && mem_pools->num_early_PMCs_seen >=
+ mem_pools->num_early_gc_PMCs) {
return 1;
}
/* TODO propagate flag in Parrot_gc_mark_PObj_alive */
- arena_base->gc_trace_ptr = current;
+ mem_pools->gc_trace_ptr = current;
if (!PObj_needs_early_gc_TEST(current))
PObj_high_priority_gc_CLEAR(current);
@@ -1667,7 +1667,7 @@
/*
-=item C<static int sweep_cb_pmc(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
+=item C<static int sweep_cb_pmc(PARROT_INTERP, Fixed_Size_Pool *pool, int
flag, void *arg)>
move everything from white up to the free_list to the free_list
@@ -1679,18 +1679,18 @@
*/
static int
-sweep_cb_pmc(PARROT_INTERP, ARGIN(Fixed_Size_Obj_Pool *pool), int flag, SHIM(void *arg))
+sweep_cb_pmc(PARROT_INTERP, ARGIN(Fixed_Size_Pool *pool), int flag, SHIM(void *arg))
{
ASSERT_ARGS(sweep_cb_pmc)
Gc_gms_hdr *h;
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
/* TODO object stats */
for (h = pool->white; h != pool->free_list; h = h->next) {
PMC * const obj = (PMC*)GMSH_to_PObj(h);
if (PObj_needs_early_gc_TEST(obj))
- --arena_base->num_early_gc_PMCs;
+ --mem_pools->num_early_gc_PMCs;
if (PObj_custom_destroy_TEST(obj))
VTABLE_destroy(interp, (PMC *)obj);
}
@@ -1700,7 +1700,7 @@
/*
-=item C<static int sweep_cb_buf(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
+=item C<static int sweep_cb_buf(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool), int flag, SHIM(void *arg))
+sweep_cb_buf(PARROT_INTERP, ARGMOD(Fixed_Size_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)) {
- ((Var_Size_Obj_Pool *)
+ ((Variable_Size_Pool *)
pool->mem_pool)->guaranteed_reclaimable +=
PObj_buflen(obj);
}
- ((Var_Size_Obj_Pool *)
+ ((Variable_Size_Pool *)
pool->mem_pool)->possibly_reclaimable +=
PObj_buflen(obj);
}
@@ -1787,7 +1787,7 @@
/*
-=item C<static int end_cycle_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int
+=item C<static int end_cycle_cb(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool), int flag, SHIM(void *arg))
+end_cycle_cb(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool), int flag, SHIM(void *arg))
{
ASSERT_ARGS(end_cycle_cb)
Gc_gms_hdr *h;
@@ -1854,30 +1854,30 @@
parrot_gc_gms_run(PARROT_INTERP, UINTVAL flags)
{
ASSERT_ARGS(parrot_gc_gms_run)
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
Gc_gms_private *g_gms;
- if (arena_base->gc_mark_block_level) {
+ if (mem_pools->gc_mark_block_level) {
return;
}
- ++arena_base->gc_mark_block_level;
- g_gms = arena_base->gc_private;
+ ++mem_pools->gc_mark_block_level;
+ g_gms = mem_pools->gc_private;
if (flags & GC_finish_FLAG) {
- Fixed_Size_Obj_Pool * const pool = arena_base->pmc_pool;
+ Fixed_Size_Pool * const pool = mem_pools->pmc_pool;
pool->white = pool->marker.next;
/* XXX need to sweep over objects that have finalizers only */
header_pools_iterate_callback(interp, POOL_PMC, 0, sweep_cb_pmc);
gc_gms_end_cycle(interp);
- --arena_base->gc_mark_block_level;
+ --mem_pools->gc_mark_block_level;
return;
}
/* normal or lazy mark run */
- arena_base->gc_mark_runs++;
- arena_base->lazy_gc = (flags & GC_lazy_FLAG);
+ mem_pools->gc_mark_runs++;
+ mem_pools->lazy_gc = (flags & GC_lazy_FLAG);
gc_gms_init_mark(interp);
- if (gc_gms_trace_root(interp, !arena_base->lazy_gc) &&
+ if (gc_gms_trace_root(interp, !mem_pools->lazy_gc) &&
gc_gms_trace_children(interp)) {
gc_gms_sweep(interp);
gc_gms_set_gen(interp);
@@ -1886,15 +1886,15 @@
/*
* successful lazy mark run
*/
- ++arena_base->gc_lazy_mark_runs;
+ ++mem_pools->gc_lazy_mark_runs;
}
gc_gms_end_cycle(interp);
- --arena_base->gc_mark_block_level;
+ --mem_pools->gc_mark_block_level;
}
/*
-=item C<static void gms_debug_verify(PARROT_INTERP, Fixed_Size_Obj_Pool *pool,
+=item C<static void gms_debug_verify(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool), ARGIN(const char *action))
+gms_debug_verify(PARROT_INTERP, ARGMOD(Fixed_Size_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 Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/src/gc/generational_ms.h Mon Sep 7 01:02:27 2009 (r41088)
@@ -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 Fixed_Size_Obj_Pool *pool; /* where this generation belongs to */
+ struct Fixed_Size_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 Fixed_Size_Obj_Pool struct's gc_sys_private_data field. */
+/* System-specific data for the Fixed_Size_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 Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/src/gc/incremental_ms.c Mon Sep 7 01:02:27 2009 (r41088)
@@ -134,7 +134,7 @@
=head2 Data structure overview
The incremental mark and sweep collector has an additional structure in
-the arena_base that keeps track of the collector's state. Pool and arena
+the mem_pools that keeps track of the collector's state. Pool and arena
structures are unchanged. Only the allocation of new arena blocks is done
much more fine grained in e.g. 8K blocks.
@@ -338,7 +338,7 @@
/* Don't modify between HEADERIZER BEGIN / HEADERIZER END. Your changes will be lost. */
static int collect_cb(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool))
+ ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool))
+ ARGMOD(Fixed_Size_Pool *pool))
__attribute__nonnull__(1)
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
-static void gc_ims_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
+static void gc_ims_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Pool *pool))
__attribute__nonnull__(2)
FUNC_MODIFIES(*pool);
@@ -395,7 +395,7 @@
__attribute__nonnull__(1);
static int sweep_cb(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Pool *pool),
int flag,
ARGIN(void *arg))
__attribute__nonnull__(1)
@@ -520,8 +520,8 @@
Parrot_gc_ims_init(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_ims_init)
- Arenas * const arena_base = interp->arena_base;
- arena_base->gc_private = mem_allocate_zeroed_typed(Gc_ims_private);
+ Memory_Pools * const mem_pools = interp->mem_pools;
+ mem_pools->gc_private = mem_allocate_zeroed_typed(Gc_ims_private);
/* set function hooks according to pdd09 */
@@ -536,7 +536,7 @@
/*
-=item C<static void gc_ims_pool_init(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
+=item C<static void gc_ims_pool_init(PARROT_INTERP, Fixed_Size_Pool *pool)>
Initializes a pool by setting the appropriate function pointers to add, get,
and allocate objects.
@@ -546,7 +546,7 @@
*/
static void
-gc_ims_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
+gc_ims_pool_init(SHIM_INTERP, ARGMOD(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(gc_ims_pool_init)
pool->add_free_object = gc_ims_add_free_object;
@@ -570,10 +570,10 @@
parrot_gc_ims_deinit(PARROT_INTERP)
{
ASSERT_ARGS(parrot_gc_ims_deinit)
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
- mem_sys_free(arena_base->gc_private);
- arena_base->gc_private = NULL;
+ mem_sys_free(mem_pools->gc_private);
+ mem_pools->gc_private = NULL;
}
@@ -593,9 +593,9 @@
{
ASSERT_ARGS(parrot_gc_ims_reinit)
Gc_ims_private *g_ims;
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
- arena_base->lazy_gc = 0;
+ mem_pools->lazy_gc = 0;
Parrot_gc_run_init(interp);
/*
@@ -604,7 +604,7 @@
*/
Parrot_gc_trace_root(interp, GC_TRACE_ROOT_ONLY);
- g_ims = (Gc_ims_private *)arena_base->gc_private;
+ g_ims = (Gc_ims_private *)mem_pools->gc_private;
g_ims->state = GC_IMS_MARKING;
}
@@ -612,7 +612,7 @@
/*
-=item C<static void gc_ims_add_free_object(PARROT_INTERP, Fixed_Size_Obj_Pool
+=item C<static void gc_ims_add_free_object(PARROT_INTERP, Fixed_Size_Pool
*pool, void *to_add)>
Add object C<to_add> to the free_list in the given pool.
@@ -623,7 +623,7 @@
*/
static void
-gc_ims_add_free_object(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), ARGOUT(void *to_add))
+gc_ims_add_free_object(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool), ARGOUT(void *to_add))
{
ASSERT_ARGS(gc_ims_add_free_object)
*(void **)to_add = pool->free_list;
@@ -631,7 +631,7 @@
#if DISABLE_GC_DEBUG
UNUSED(interp);
#else
- if (GC_DEBUG(interp) && pool == interp->arena_base->pmc_pool) {
+ if (GC_DEBUG(interp) && pool == interp->mem_pools->pmc_pool) {
PMC * const p = (PMC *)to_add;
p->vtable = interp->vtables[enum_class_Null];
}
@@ -640,7 +640,7 @@
/*
-=item C<static void * gc_ims_get_free_object(PARROT_INTERP, Fixed_Size_Obj_Pool
+=item C<static void * gc_ims_get_free_object(PARROT_INTERP, Fixed_Size_Pool
*pool)>
Get a new object off the free_list in the given pool.
@@ -652,12 +652,12 @@
PARROT_CANNOT_RETURN_NULL
PARROT_WARN_UNUSED_RESULT
static void *
-gc_ims_get_free_object(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
+gc_ims_get_free_object(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(gc_ims_get_free_object)
PObj *ptr;
- Arenas * const arena_base = interp->arena_base;
- Gc_ims_private * const g_ims = (Gc_ims_private *)arena_base->gc_private;
+ Memory_Pools * const mem_pools = interp->mem_pools;
+ Gc_ims_private * const g_ims = (Gc_ims_private *)mem_pools->gc_private;
if (++g_ims->allocations >= g_ims->alloc_trigger) {
g_ims->allocations = 0;
@@ -676,7 +676,7 @@
* XXX this does not solve the problem of storing keys in hashes
* in the next mark phase (if the key isn't marked elsewhere ?)
*/
- PObj_flags_SETTO(ptr, pool == arena_base->pmc_pool ? 0 : PObj_live_FLAG);
+ PObj_flags_SETTO(ptr, pool == mem_pools->pmc_pool ? 0 : PObj_live_FLAG);
--pool->num_free_objects;
return (void *)ptr;
}
@@ -684,7 +684,7 @@
/*
-=item C<static void gc_ims_alloc_objects(PARROT_INTERP, Fixed_Size_Obj_Pool
+=item C<static void gc_ims_alloc_objects(PARROT_INTERP, Fixed_Size_Pool
*pool)>
Allocate new objects for the given pool.
@@ -694,7 +694,7 @@
*/
static void
-gc_ims_alloc_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool))
+gc_ims_alloc_objects(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(gc_ims_alloc_objects)
Fixed_Size_Obj_Arena *new_arena;
@@ -734,8 +734,8 @@
double work_factor;
PMC *next;
- Arenas * const arena_base = (Arenas *)interp->arena_base;
- Gc_ims_private * const g_ims = (Gc_ims_private *)arena_base->gc_private;
+ Memory_Pools * const mem_pools = (Memory_Pools *)interp->mem_pools;
+ Gc_ims_private * const g_ims = (Gc_ims_private *)mem_pools->gc_private;
/* use statistics from the previous run */
if (g_ims->n_objects)
@@ -745,11 +745,11 @@
todo = (size_t)(g_ims->alloc_trigger * g_ims->throttle * work_factor);
- PARROT_ASSERT(arena_base->lazy_gc == 0);
+ PARROT_ASSERT(mem_pools->lazy_gc == 0);
Parrot_gc_trace_children(interp, todo);
/* check if we are finished with marking -- the end is self-referential */
- next = arena_base->gc_mark_start;
+ next = mem_pools->gc_mark_start;
if (next == PMC_next_for_GC(next))
g_ims->state = GC_IMS_START_SWEEP;
@@ -758,7 +758,7 @@
/*
-=item C<static int sweep_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int flag,
+=item C<static int sweep_cb(PARROT_INTERP, Fixed_Size_Pool *pool, int flag,
void *arg)>
Callback to sweep a header pool (see header_pools_iterate_callback).
@@ -768,7 +768,7 @@
*/
static int
-sweep_cb(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), int flag, ARGIN(void *arg))
+sweep_cb(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool), int flag, ARGIN(void *arg))
{
ASSERT_ARGS(sweep_cb)
int * const n_obj = (int *)arg;
@@ -800,8 +800,8 @@
parrot_gc_ims_sweep(PARROT_INTERP)
{
ASSERT_ARGS(parrot_gc_ims_sweep)
- Arenas * const arena_base = interp->arena_base;
- Gc_ims_private *g_ims = (Gc_ims_private *)arena_base->gc_private;
+ Memory_Pools * const mem_pools = interp->mem_pools;
+ Gc_ims_private *g_ims = (Gc_ims_private *)mem_pools->gc_private;
size_t n_objects;
int ignored;
@@ -836,7 +836,7 @@
/*
-=item C<static int collect_cb(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, int flag,
+=item C<static int collect_cb(PARROT_INTERP, Fixed_Size_Pool *pool, int flag,
void *arg)>
Callback to collect a header pool (see header_pools_iterate_callback).
@@ -848,11 +848,11 @@
#if !defined(GC_IS_MALLOC) || !GC_IS_MALLOC
static int
-collect_cb(PARROT_INTERP, ARGMOD(Fixed_Size_Obj_Pool *pool), SHIM(int flag), ARGIN(void *arg))
+collect_cb(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool), SHIM(int flag), ARGIN(void *arg))
{
ASSERT_ARGS(collect_cb)
const int check_only = (int)(INTVAL)arg;
- Var_Size_Obj_Pool * const mem_pool = pool->mem_pool;
+ Variable_Size_Pool * const mem_pool = pool->mem_pool;
/* check if there is an associated memory pool */
if (!mem_pool)
@@ -903,14 +903,14 @@
UNUSED(interp);
UNUSED(check_only);
#else
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
Gc_ims_private *g_ims;
int ret;
if (!check_only && interp->profile)
Parrot_gc_profile_start(interp);
- g_ims = (Gc_ims_private *)arena_base->gc_private;
+ g_ims = (Gc_ims_private *)mem_pools->gc_private;
ret = header_pools_iterate_callback(interp, POOL_BUFFER,
(void *)(long)check_only, collect_cb);
@@ -945,10 +945,10 @@
parrot_gc_ims_run_increment(PARROT_INTERP)
{
ASSERT_ARGS(parrot_gc_ims_run_increment)
- Arenas * const arena_base = interp->arena_base;
- Gc_ims_private * const g_ims = (Gc_ims_private *)arena_base->gc_private;
+ Memory_Pools * const mem_pools = interp->mem_pools;
+ Gc_ims_private * const g_ims = (Gc_ims_private *)mem_pools->gc_private;
- if (arena_base->gc_mark_block_level || g_ims->state == GC_IMS_DEAD)
+ if (mem_pools->gc_mark_block_level || g_ims->state == GC_IMS_DEAD)
return;
++g_ims->increments;
@@ -981,7 +981,7 @@
(void)parrot_gc_ims_collect(interp, 0);
break;
case GC_IMS_FINISHED:
- ++arena_base->gc_mark_runs;
+ ++mem_pools->gc_mark_runs;
g_ims->state = GC_IMS_CONSUMING;
/* fall through */
case GC_IMS_CONSUMING:
@@ -990,12 +990,12 @@
* There shouldn't be other pools that could run out of
* headers independent of PMCs
*/
- if (arena_base->pmc_pool->num_free_objects <
- arena_base->pmc_pool->total_objects * REFILL_FACTOR) {
+ if (mem_pools->pmc_pool->num_free_objects <
+ mem_pools->pmc_pool->total_objects * REFILL_FACTOR) {
g_ims->state = GC_IMS_STARTING;
}
- else if (arena_base->string_header_pool->num_free_objects <
- arena_base->string_header_pool->total_objects *
+ else if (mem_pools->string_header_pool->num_free_objects <
+ mem_pools->string_header_pool->total_objects *
REFILL_FACTOR) {
g_ims->state = GC_IMS_STARTING;
}
@@ -1026,10 +1026,10 @@
{
ASSERT_ARGS(parrot_gc_ims_run)
int lazy;
- Arenas * const arena_base = interp->arena_base;
- Gc_ims_private * const g_ims = (Gc_ims_private *)arena_base->gc_private;
+ Memory_Pools * const mem_pools = interp->mem_pools;
+ Gc_ims_private * const g_ims = (Gc_ims_private *)mem_pools->gc_private;
- if (arena_base->gc_mark_block_level || g_ims->state == GC_IMS_DEAD)
+ if (mem_pools->gc_mark_block_level || g_ims->state == GC_IMS_DEAD)
return;
if (flags & GC_finish_FLAG) {
@@ -1041,16 +1041,16 @@
* Be sure live bits are clear.
*/
if (g_ims->state >= GC_IMS_RE_INIT || g_ims->state < GC_IMS_FINISHED)
- Parrot_gc_clear_live_bits(interp, arena_base->pmc_pool);
+ Parrot_gc_clear_live_bits(interp, mem_pools->pmc_pool);
- Parrot_gc_sweep_pool(interp, interp->arena_base->pmc_pool);
+ Parrot_gc_sweep_pool(interp, interp->mem_pools->pmc_pool);
g_ims->state = GC_IMS_DEAD;
return;
}
/* make the test happy that checks the count ;) */
- arena_base->gc_mark_runs++;
+ mem_pools->gc_mark_runs++;
lazy = flags & GC_lazy_FLAG;
@@ -1083,7 +1083,7 @@
if (g_ims->state >= GC_IMS_COLLECT) {
/* we are beyond sweep, timely destruction is done */
- if (arena_base->num_early_PMCs_seen >= arena_base->num_early_gc_PMCs)
+ if (mem_pools->num_early_PMCs_seen >= mem_pools->num_early_gc_PMCs)
return;
/* when not all seen, start a fresh cycle */
@@ -1097,7 +1097,7 @@
* run through all steps until we see enough PMCs that need timely
* destruction or we finished sweeping
*/
- while (arena_base->num_early_PMCs_seen < arena_base->num_early_gc_PMCs) {
+ while (mem_pools->num_early_PMCs_seen < mem_pools->num_early_gc_PMCs) {
parrot_gc_ims_run_increment(interp);
if (g_ims->state >= GC_IMS_COLLECT)
break;
@@ -1105,7 +1105,7 @@
/* if we stopped early, the lazy run was successful */
if (g_ims->state < GC_IMS_COLLECT)
- ++arena_base->gc_lazy_mark_runs;
+ ++mem_pools->gc_lazy_mark_runs;
g_ims->lazy = 0;
}
@@ -1131,7 +1131,7 @@
ASSERT_ARGS(Parrot_gc_ims_wb)
#if GC_IMS_GREY_NEW
IMS_DEBUG((stderr, "%d agg %p mark %p\n",
- ((Gc_ims_private *)interp->arena_base->
+ ((Gc_ims_private *)interp->mem_pools->
gc_private)->state, agg, _new));
Parrot_gc_mark_PObj_alive(interp, (PObj*)_new);
#else
Modified: branches/gc-refactor/src/gc/mark_sweep.c
==============================================================================
--- branches/gc-refactor/src/gc/mark_sweep.c Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/src/gc/mark_sweep.c Mon Sep 7 01:02:27 2009 (r41088)
@@ -32,7 +32,7 @@
/* Don't modify between HEADERIZER BEGIN / HEADERIZER END. Your changes will be lost. */
static void free_buffer(SHIM_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+ SHIM(Fixed_Size_Pool *pool),
ARGMOD(Buffer *b))
__attribute__nonnull__(3)
FUNC_MODIFIES(*b);
static void free_pmc_in_pool(PARROT_INTERP,
- SHIM(Fixed_Size_Obj_Pool *pool),
+ SHIM(Fixed_Size_Pool *pool),
ARGMOD(PObj *p))
__attribute__nonnull__(1)
__attribute__nonnull__(3)
@@ -54,24 +54,24 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-static Fixed_Size_Obj_Pool * new_bufferlike_pool(PARROT_INTERP,
+static Fixed_Size_Pool * new_bufferlike_pool(PARROT_INTERP,
size_t actual_buffer_size)
__attribute__nonnull__(1);
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-static Fixed_Size_Obj_Pool * new_pmc_pool(PARROT_INTERP)
+static Fixed_Size_Pool * new_pmc_pool(PARROT_INTERP)
__attribute__nonnull__(1);
PARROT_MALLOC
PARROT_CANNOT_RETURN_NULL
-static Fixed_Size_Obj_Pool * new_fixed_size_obj_pool(
+static Fixed_Size_Pool * new_fixed_size_obj_pool(
size_t object_size,
size_t objects_per_alloc);
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-static Fixed_Size_Obj_Pool * new_string_pool(PARROT_INTERP, INTVAL constant)
+static Fixed_Size_Pool * new_string_pool(PARROT_INTERP, INTVAL constant)
__attribute__nonnull__(1);
static void Parrot_gc_allocate_new_attributes_arena(PARROT_INTERP,
@@ -117,7 +117,7 @@
=item C<void Parrot_gc_run_init(PARROT_INTERP)>
Prepares the collector for a mark & sweep GC run. Initializes the various
-fields in the Arenas structure that need to be zeroed out prior to the
+fields in the Memory_Pools structure that need to be zeroed out prior to the
mark phase.
=cut
@@ -128,11 +128,11 @@
Parrot_gc_run_init(PARROT_INTERP)
{
ASSERT_ARGS(Parrot_gc_run_init)
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
- arena_base->gc_trace_ptr = NULL;
- arena_base->gc_mark_start = NULL;
- arena_base->num_early_PMCs_seen = 0;
+ mem_pools->gc_trace_ptr = NULL;
+ mem_pools->gc_mark_start = NULL;
+ mem_pools->num_early_PMCs_seen = 0;
}
/*
@@ -169,7 +169,7 @@
Parrot_gc_trace_root(PARROT_INTERP, Parrot_gc_trace_type trace)
{
ASSERT_ARGS(Parrot_gc_trace_root)
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
PObj *obj;
/* note: adding locals here did cause increased GC runs */
@@ -184,9 +184,9 @@
Parrot_gc_profile_start(interp);
/* We have to start somewhere; the interpreter globals is a good place */
- if (!arena_base->gc_mark_start) {
- arena_base->gc_mark_start
- = arena_base->gc_mark_ptr
+ if (!mem_pools->gc_mark_start) {
+ mem_pools->gc_mark_start
+ = mem_pools->gc_mark_ptr
= interp->iglobals;
}
@@ -244,8 +244,8 @@
/* quick check to see if we have already marked all impatient PMCs. If we
have, return 0 and exit here. This will alert other parts of the GC
that if we are in a lazy run we can just stop it. */
- if (arena_base->lazy_gc
- && arena_base->num_early_PMCs_seen >= arena_base->num_early_gc_PMCs)
+ if (mem_pools->lazy_gc
+ && mem_pools->num_early_PMCs_seen >= mem_pools->num_early_gc_PMCs)
return 0;
if (interp->profile)
@@ -257,7 +257,7 @@
/*
-=item C<void Parrot_gc_sweep_pool(PARROT_INTERP, Fixed_Size_Obj_Pool *pool)>
+=item C<void Parrot_gc_sweep_pool(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool))
+Parrot_gc_sweep_pool(PARROT_INTERP, ARGMOD(Fixed_Size_Pool *pool))
{
ASSERT_ARGS(Parrot_gc_sweep_pool)
PObj *b;
@@ -352,7 +352,7 @@
/*
-=item C<INTVAL contained_in_pool(PARROT_INTERP, const Fixed_Size_Obj_Pool *pool,
+=item C<INTVAL contained_in_pool(PARROT_INTERP, const Fixed_Size_Pool *pool,
const void *ptr)>
Returns whether the given C<*ptr> points to a location in C<pool>.
@@ -363,7 +363,7 @@
PARROT_WARN_UNUSED_RESULT
INTVAL
-contained_in_pool(PARROT_INTERP, ARGIN(const Fixed_Size_Obj_Pool *pool), ARGIN(const void *ptr))
+contained_in_pool(PARROT_INTERP, ARGIN(const Fixed_Size_Pool *pool), ARGIN(const void *ptr))
{
ASSERT_ARGS(contained_in_pool)
const Fixed_Size_Obj_Arena *arena;
@@ -401,7 +401,7 @@
{
ASSERT_ARGS(mark_special)
int hi_prio;
- Arenas *arena_base;
+ Memory_Pools *mem_pools;
/*
* If the object is shared, we have to use the arena and gc
@@ -418,25 +418,25 @@
interp = PMC_sync(obj)->owner;
PARROT_ASSERT(interp);
- if (!interp->arena_base->gc_mark_ptr)
- interp->arena_base->gc_mark_ptr = obj;
+ if (!interp->mem_pools->gc_mark_ptr)
+ interp->mem_pools->gc_mark_ptr = obj;
}
- arena_base = interp->arena_base;
+ mem_pools = interp->mem_pools;
if (PObj_needs_early_gc_TEST(obj))
- ++arena_base->num_early_PMCs_seen;
+ ++mem_pools->num_early_PMCs_seen;
- if (PObj_high_priority_gc_TEST(obj) && arena_base->gc_trace_ptr) {
+ if (PObj_high_priority_gc_TEST(obj) && mem_pools->gc_trace_ptr) {
/* set obj's parent to high priority */
- PObj_high_priority_gc_SET(arena_base->gc_trace_ptr);
+ PObj_high_priority_gc_SET(mem_pools->gc_trace_ptr);
hi_prio = 1;
}
else
hi_prio = 0;
{
- PMC * const tptr = arena_base->gc_trace_ptr;
+ PMC * const tptr = mem_pools->gc_trace_ptr;
/*
* XXX this basically invalidates the high-priority marking
* of PMCs by putting all PMCs onto the front of the list.
@@ -458,11 +458,11 @@
}
else {
/* put it on the end of the list */
- PMC_next_for_GC(arena_base->gc_mark_ptr) = obj;
+ PMC_next_for_GC(mem_pools->gc_mark_ptr) = obj;
/* Explicitly make the tail of the linked list be
* self-referential */
- arena_base->gc_mark_ptr = PMC_next_for_GC(obj) = obj;
+ mem_pools->gc_mark_ptr = PMC_next_for_GC(obj) = obj;
}
}
if (PObj_custom_mark_TEST(obj)) {
@@ -475,7 +475,7 @@
/*
-=item C<void Parrot_gc_clear_live_bits(PARROT_INTERP, const Fixed_Size_Obj_Pool
+=item C<void Parrot_gc_clear_live_bits(PARROT_INTERP, const Fixed_Size_Pool
*pool)>
Resets the PMC pool, so all objects are marked as "White". This
@@ -487,7 +487,7 @@
*/
void
-Parrot_gc_clear_live_bits(PARROT_INTERP, ARGIN(const Fixed_Size_Obj_Pool *pool))
+Parrot_gc_clear_live_bits(PARROT_INTERP, ARGIN(const Fixed_Size_Pool *pool))
{
ASSERT_ARGS(Parrot_gc_clear_live_bits)
Fixed_Size_Obj_Arena *arena;
@@ -521,9 +521,9 @@
Parrot_gc_trace_children(PARROT_INTERP, size_t how_many)
{
ASSERT_ARGS(Parrot_gc_trace_children)
- Arenas * const arena_base = interp->arena_base;
- const int lazy_gc = arena_base->lazy_gc;
- PMC *current = arena_base->gc_mark_start;
+ Memory_Pools * const mem_pools = interp->mem_pools;
+ const int lazy_gc = mem_pools->lazy_gc;
+ PMC *current = mem_pools->gc_mark_start;
/*
* First phase of mark is finished. Now if we are the owner
@@ -542,12 +542,12 @@
do {
PMC *next;
- if (lazy_gc && arena_base->num_early_PMCs_seen >=
- arena_base->num_early_gc_PMCs) {
+ if (lazy_gc && mem_pools->num_early_PMCs_seen >=
+ mem_pools->num_early_gc_PMCs) {
return 0;
}
- arena_base->gc_trace_ptr = current;
+ mem_pools->gc_trace_ptr = current;
/* short-term hack to color objects black */
PObj_get_FLAGS(current) |= PObj_custom_GC_FLAG;
@@ -573,8 +573,8 @@
current = next;
} while (--how_many > 0);
- arena_base->gc_mark_start = current;
- arena_base->gc_trace_ptr = NULL;
+ mem_pools->gc_mark_start = current;
+ mem_pools->gc_trace_ptr = NULL;
if (interp->profile)
Parrot_gc_profile_end(interp, PARROT_PROF_GC_p2);
@@ -584,7 +584,7 @@
/*
-=item C<void Parrot_add_to_free_list(PARROT_INTERP, Fixed_Size_Obj_Pool *pool,
+=item C<void Parrot_add_to_free_list(PARROT_INTERP, Fixed_Size_Pool *pool,
Fixed_Size_Obj_Arena *arena)>
Adds the objects in the newly allocated C<arena> to the free list of the pool.
@@ -595,7 +595,7 @@
void
Parrot_add_to_free_list(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Pool *pool),
ARGMOD(Fixed_Size_Obj_Arena *arena))
{
ASSERT_ARGS(Parrot_add_to_free_list)
@@ -628,10 +628,10 @@
/*
-=item C<void Parrot_append_arena_in_pool(PARROT_INTERP, Fixed_Size_Obj_Pool *pool,
+=item C<void Parrot_append_arena_in_pool(PARROT_INTERP, Fixed_Size_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
+Insert the new arena into the pool's structure. Memory_Pools are stored in a
linked list, so add the new arena to the list. Set information in the
arenas structure, such as the number of objects allocated in it.
@@ -641,7 +641,7 @@
void
Parrot_append_arena_in_pool(PARROT_INTERP,
- ARGMOD(Fixed_Size_Obj_Pool *pool),
+ ARGMOD(Fixed_Size_Pool *pool),
ARGMOD(Fixed_Size_Obj_Arena *new_arena), size_t size)
{
ASSERT_ARGS(Parrot_append_arena_in_pool)
@@ -664,7 +664,7 @@
new_arena->prev->next = new_arena;
pool->last_Arena = new_arena;
- interp->arena_base->header_allocs_since_last_collect++;
+ interp->mem_pools->header_allocs_since_last_collect++;
}
/*
@@ -728,7 +728,7 @@
=over 4
-=item C<static Fixed_Size_Obj_Pool * new_pmc_pool(PARROT_INTERP)>
+=item C<static Fixed_Size_Pool * new_pmc_pool(PARROT_INTERP)>
Creates and initializes a new pool for PMCs and returns it.
@@ -738,12 +738,12 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-static Fixed_Size_Obj_Pool *
+static Fixed_Size_Pool *
new_pmc_pool(PARROT_INTERP)
{
ASSERT_ARGS(new_pmc_pool)
const int num_headers = PMC_HEADERS_PER_ALLOC;
- Fixed_Size_Obj_Pool * const pmc_pool =
+ Fixed_Size_Pool * const pmc_pool =
new_fixed_size_obj_pool(sizeof (PMC), num_headers);
pmc_pool->mem_pool = NULL;
@@ -755,7 +755,7 @@
/*
-=item C<static void free_pmc_in_pool(PARROT_INTERP, Fixed_Size_Obj_Pool *pool,
+=item C<static void free_pmc_in_pool(PARROT_INTERP, Fixed_Size_Pool *pool,
PObj *p)>
Frees a PMC that is no longer being used. Calls a custom C<destroy> VTABLE
@@ -766,16 +766,16 @@
*/
static void
-free_pmc_in_pool(PARROT_INTERP, SHIM(Fixed_Size_Obj_Pool *pool),
+free_pmc_in_pool(PARROT_INTERP, SHIM(Fixed_Size_Pool *pool),
ARGMOD(PObj *p))
{
ASSERT_ARGS(free_pmc_in_pool)
PMC * const pmc = (PMC *)p;
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
/* TODO collect objects with finalizers */
if (PObj_needs_early_gc_TEST(p))
- --arena_base->num_early_gc_PMCs;
+ --mem_pools->num_early_gc_PMCs;
Parrot_pmc_destroy(interp, pmc);
}
@@ -783,7 +783,7 @@
/*
-=item C<static Fixed_Size_Obj_Pool * new_bufferlike_pool(PARROT_INTERP, size_t
+=item C<static Fixed_Size_Pool * new_bufferlike_pool(PARROT_INTERP, size_t
actual_buffer_size)>
Creates a new pool for buffer-like structures. This is called from
@@ -795,14 +795,14 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-static Fixed_Size_Obj_Pool *
+static Fixed_Size_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);
- Fixed_Size_Obj_Pool * const pool =
+ Fixed_Size_Pool * const pool =
new_fixed_size_obj_pool(buffer_size, num_headers);
#ifdef GC_IS_MALLOC
@@ -811,17 +811,17 @@
pool->gc_object = (gc_object_fn_type)free_buffer;
#endif
- pool->mem_pool = interp->arena_base->memory_pool;
+ pool->mem_pool = interp->mem_pools->memory_pool;
(interp->gc_sys->init_pool)(interp, pool);
return pool;
}
/*
-=item C<static Fixed_Size_Obj_Pool * new_fixed_size_obj_pool(size_t object_size,
+=item C<static Fixed_Size_Pool * new_fixed_size_obj_pool(size_t object_size,
size_t objects_per_alloc)>
-Creates a new C<Fixed_Size_Obj_Pool> and returns a pointer to it.
+Creates a new C<Fixed_Size_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 Fixed_Size_Obj_Pool *
+static Fixed_Size_Pool *
new_fixed_size_obj_pool(size_t object_size, size_t objects_per_alloc)
{
ASSERT_ARGS(new_fixed_size_obj_pool)
- Fixed_Size_Obj_Pool * const pool =
- mem_internal_allocate_zeroed_typed(Fixed_Size_Obj_Pool);
+ Fixed_Size_Pool * const pool =
+ mem_internal_allocate_zeroed_typed(Fixed_Size_Pool);
pool->last_Arena = NULL;
pool->free_list = NULL;
@@ -853,7 +853,7 @@
/*
-=item C<static Fixed_Size_Obj_Pool * new_string_pool(PARROT_INTERP, INTVAL
+=item C<static Fixed_Size_Pool * new_string_pool(PARROT_INTERP, INTVAL
constant)>
Creates a new pool for C<STRING>s and returns it. This calls
@@ -865,15 +865,15 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-static Fixed_Size_Obj_Pool *
+static Fixed_Size_Pool *
new_string_pool(PARROT_INTERP, INTVAL constant)
{
ASSERT_ARGS(new_string_pool)
- Fixed_Size_Obj_Pool *pool;
+ Fixed_Size_Pool *pool;
if (constant) {
pool = new_bufferlike_pool(interp, sizeof (STRING));
pool->gc_object = NULL;
- pool->mem_pool = interp->arena_base->constant_string_pool;
+ pool->mem_pool = interp->mem_pools->constant_string_pool;
}
else
pool = get_bufferlike_pool(interp, sizeof (STRING));
@@ -885,7 +885,7 @@
/*
-=item C<static void free_buffer_malloc(PARROT_INTERP, Fixed_Size_Obj_Pool *pool,
+=item C<static void free_buffer_malloc(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool),
+free_buffer_malloc(SHIM_INTERP, SHIM(Fixed_Size_Pool *pool),
ARGMOD(Buffer *b))
{
ASSERT_ARGS(free_buffer_malloc)
@@ -921,7 +921,7 @@
/*
-=item C<static void free_buffer(PARROT_INTERP, Fixed_Size_Obj_Pool *pool, Buffer
+=item C<static void free_buffer(PARROT_INTERP, Fixed_Size_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(Fixed_Size_Obj_Pool *pool), ARGMOD(Buffer *b))
+free_buffer(SHIM_INTERP, ARGMOD(Fixed_Size_Pool *pool), ARGMOD(Buffer *b))
{
ASSERT_ARGS(free_buffer)
- Var_Size_Obj_Pool * const mem_pool = (Var_Size_Obj_Pool *)pool->mem_pool;
+ Variable_Size_Pool * const mem_pool = (Variable_Size_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<Fixed_Size_Obj_Pool * get_bufferlike_pool(PARROT_INTERP, size_t
+=item C<Fixed_Size_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,12 +965,12 @@
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
-Fixed_Size_Obj_Pool *
+Fixed_Size_Pool *
get_bufferlike_pool(PARROT_INTERP, size_t buffer_size)
{
ASSERT_ARGS(get_bufferlike_pool)
- Fixed_Size_Obj_Pool **sized_pools = interp->arena_base->sized_header_pools;
- const UINTVAL num_old = interp->arena_base->num_sized;
+ Fixed_Size_Pool **sized_pools = interp->mem_pools->sized_header_pools;
+ const UINTVAL num_old = interp->mem_pools->num_sized;
const UINTVAL idx = GET_SIZED_POOL_IDX(buffer_size);
/* Expands the array of sized resource pools, if necessary */
@@ -980,12 +980,12 @@
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 = (Fixed_Size_Obj_Pool **)mem_internal_realloc(sized_pools,
+ sized_pools = (Fixed_Size_Pool **)mem_internal_realloc(sized_pools,
num_new * sizeof (void *));
memset(sized_pools + num_old, 0, sizeof (void *) * (num_new - num_old));
- interp->arena_base->sized_header_pools = sized_pools;
- interp->arena_base->num_sized = num_new;
+ interp->mem_pools->sized_header_pools = sized_pools;
+ interp->mem_pools->num_sized = num_new;
}
if (sized_pools[idx] == NULL)
@@ -996,7 +996,7 @@
/*
-=item C<void initialize_header_pools(PARROT_INTERP)>
+=item C<void initialize_fixed_size_pools(PARROT_INTERP)>
The initialization routine for the interpreter's header pools. Initializes
pools for string headers, constant string headers, buffers, PMCs and
@@ -1010,14 +1010,14 @@
*/
void
-initialize_header_pools(PARROT_INTERP)
+initialize_fixed_size_pools(PARROT_INTERP)
{
- ASSERT_ARGS(initialize_header_pools)
- Arenas * const arena_base = interp->arena_base;
+ ASSERT_ARGS(initialize_fixed_size_pools)
+ Memory_Pools * const mem_pools = interp->mem_pools;
/* Init the constant string header pool */
- arena_base->constant_string_header_pool = new_string_pool(interp, 1);
- arena_base->constant_string_header_pool->name = "constant_string_header";
+ mem_pools->constant_string_header_pool = new_string_pool(interp, 1);
+ mem_pools->constant_string_header_pool->name = "constant_string_header";
/* Init the buffer header pool
*
@@ -1026,17 +1026,17 @@
* new_*_header */
/* Init the string header pool */
- arena_base->string_header_pool = new_string_pool(interp, 0);
- arena_base->string_header_pool->name = "string_header";
+ mem_pools->string_header_pool = new_string_pool(interp, 0);
+ mem_pools->string_header_pool->name = "string_header";
/* Init the PMC header pool */
- arena_base->pmc_pool = new_pmc_pool(interp);
- arena_base->pmc_pool->name = "pmc";
+ mem_pools->pmc_pool = new_pmc_pool(interp);
+ mem_pools->pmc_pool->name = "pmc";
/* constant PMCs */
- arena_base->constant_pmc_pool = new_pmc_pool(interp);
- arena_base->constant_pmc_pool->name = "constant_pmc";
- arena_base->constant_pmc_pool->objects_per_alloc =
+ mem_pools->constant_pmc_pool = new_pmc_pool(interp);
+ mem_pools->constant_pmc_pool->name = "constant_pmc";
+ mem_pools->constant_pmc_pool->objects_per_alloc =
CONSTANT_PMC_HEADERS_PER_ALLOC;
}
@@ -1072,7 +1072,7 @@
=item pool_iter_fn
-Called with C<(Parrot_Interp, Fixed_Size_Obj_Pool *, int flag, void *arg)>. If
+Called with C<(Parrot_Interp, Fixed_Size_Pool *, int flag, void *arg)>. If
the function returns a non-zero value, iteration will stop.
=back
@@ -1087,12 +1087,12 @@
NOTNULL(pool_iter_fn func))
{
ASSERT_ARGS(header_pools_iterate_callback)
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
if (flag & POOL_PMC) {
- Fixed_Size_Obj_Pool *pool = flag & POOL_CONST
- ? arena_base->constant_pmc_pool
- : arena_base->pmc_pool;
+ Fixed_Size_Pool *pool = flag & POOL_CONST
+ ? mem_pools->constant_pmc_pool
+ : mem_pools->pmc_pool;
const int ret_val = (func)(interp, pool,
flag & (POOL_PMC | POOL_CONST) , arg);
@@ -1106,15 +1106,15 @@
if (flag & POOL_CONST) {
const int ret_val = (func)(interp,
- arena_base->constant_string_header_pool,
+ mem_pools->constant_string_header_pool,
POOL_BUFFER | POOL_CONST, arg);
if (ret_val)
return ret_val;
}
- for (i = interp->arena_base->num_sized - 1; i >= 0; --i) {
- Fixed_Size_Obj_Pool * const pool = arena_base->sized_header_pools[i];
+ for (i = interp->mem_pools->num_sized - 1; i >= 0; --i) {
+ Fixed_Size_Pool * const pool = mem_pools->sized_header_pools[i];
if (pool) {
const int ret_val = (func)(interp, pool, POOL_BUFFER, arg);
@@ -1251,7 +1251,7 @@
{
ASSERT_ARGS(Parrot_gc_get_attribute_pool)
- Arenas * const arenas = interp->arena_base;
+ Memory_Pools * const arenas = interp->mem_pools;
PMC_Attribute_Pool **pools = arenas->attrib_pools;
const size_t size = (attrib_size < sizeof (void *))
? sizeof (void *)
Modified: branches/gc-refactor/src/gc/res_lea.c
==============================================================================
--- branches/gc-refactor/src/gc/res_lea.c Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/src/gc/res_lea.c Mon Sep 7 01:02:27 2009 (r41088)
@@ -46,10 +46,10 @@
Parrot_gc_compact_memory_pool(PARROT_INTERP)
{
ASSERT_ARGS(parrot_go_collect)
- if (interp->arena_base->gc_sweep_block_level) {
+ if (interp->mem_pools->gc_sweep_block_level) {
return;
}
- interp->arena_base->gc_collect_runs++; /* fake it */
+ interp->mem_pools->gc_collect_runs++; /* fake it */
}
/*
@@ -239,7 +239,7 @@
/*
-=item C<void initialize_memory_pools(PARROT_INTERP)>
+=item C<void initialize_var_size_pools(PARROT_INTERP)>
Does nothing.
@@ -248,9 +248,9 @@
*/
void
-initialize_memory_pools(PARROT_INTERP)
+initialize_var_size_pools(PARROT_INTERP)
{
- ASSERT_ARGS(parrot_initialize_memory_pools)
+ ASSERT_ARGS(parrot_initialize_var_size_pools)
}
/*
Modified: branches/gc-refactor/src/gc/system.c
==============================================================================
--- branches/gc-refactor/src/gc/system.c Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/src/gc/system.c Mon Sep 7 01:02:27 2009 (r41088)
@@ -263,14 +263,14 @@
get_max_buffer_address(PARROT_INTERP)
{
ASSERT_ARGS(get_max_buffer_address)
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
size_t max = 0;
UINTVAL i;
- for (i = 0; i < arena_base->num_sized; i++) {
- if (arena_base->sized_header_pools[i]) {
- if (arena_base->sized_header_pools[i]->end_arena_memory > max)
- max = arena_base->sized_header_pools[i]->end_arena_memory;
+ for (i = 0; i < mem_pools->num_sized; i++) {
+ if (mem_pools->sized_header_pools[i]) {
+ if (mem_pools->sized_header_pools[i]->end_arena_memory > max)
+ max = mem_pools->sized_header_pools[i]->end_arena_memory;
}
}
@@ -298,15 +298,15 @@
get_min_buffer_address(PARROT_INTERP)
{
ASSERT_ARGS(get_min_buffer_address)
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
size_t min = (size_t) -1;
UINTVAL i;
- for (i = 0; i < arena_base->num_sized; i++) {
- if (arena_base->sized_header_pools[i]
- && arena_base->sized_header_pools[i]->start_arena_memory) {
- if (arena_base->sized_header_pools[i]->start_arena_memory < min)
- min = arena_base->sized_header_pools[i]->start_arena_memory;
+ for (i = 0; i < mem_pools->num_sized; i++) {
+ if (mem_pools->sized_header_pools[i]
+ && mem_pools->sized_header_pools[i]->start_arena_memory) {
+ if (mem_pools->sized_header_pools[i]->start_arena_memory < min)
+ min = mem_pools->sized_header_pools[i]->start_arena_memory;
}
}
@@ -329,7 +329,7 @@
get_max_pmc_address(PARROT_INTERP)
{
ASSERT_ARGS(get_max_pmc_address)
- return interp->arena_base->pmc_pool->end_arena_memory;
+ return interp->mem_pools->pmc_pool->end_arena_memory;
}
@@ -350,7 +350,7 @@
get_min_pmc_address(PARROT_INTERP)
{
ASSERT_ARGS(get_min_pmc_address)
- return interp->arena_base->pmc_pool->start_arena_memory;
+ return interp->mem_pools->pmc_pool->start_arena_memory;
}
@@ -484,12 +484,12 @@
is_buffer_ptr(PARROT_INTERP, ARGIN(const void *ptr))
{
ASSERT_ARGS(is_buffer_ptr)
- Arenas * const arena_base = interp->arena_base;
+ Memory_Pools * const mem_pools = interp->mem_pools;
UINTVAL i;
- for (i = 0; i < arena_base->num_sized; i++) {
- if (arena_base->sized_header_pools[i]
- && contained_in_pool(interp, arena_base->sized_header_pools[i], ptr))
+ for (i = 0; i < mem_pools->num_sized; i++) {
+ if (mem_pools->sized_header_pools[i]
+ && contained_in_pool(interp, mem_pools->sized_header_pools[i], ptr))
return 1;
}
@@ -512,7 +512,7 @@
is_pmc_ptr(PARROT_INTERP, ARGIN(const void *ptr))
{
ASSERT_ARGS(is_pmc_ptr)
- return contained_in_pool(interp, interp->arena_base->pmc_pool, ptr);
+ return contained_in_pool(interp, interp->mem_pools->pmc_pool, ptr);
}
Modified: branches/gc-refactor/src/interp/inter_create.c
==============================================================================
--- branches/gc-refactor/src/interp/inter_create.c Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/src/interp/inter_create.c Mon Sep 7 01:02:27 2009 (r41088)
@@ -401,8 +401,8 @@
Parrot_gc_destroy_memory_pools(interp);
/* mem subsystem is dead now */
- mem_sys_free(interp->arena_base);
- interp->arena_base = NULL;
+ mem_sys_free(interp->mem_pools);
+ interp->mem_pools = NULL;
/* cache structure */
destroy_object_cache(interp);
Modified: branches/gc-refactor/t/tools/ops2pm/samples/core_ops.original
==============================================================================
--- branches/gc-refactor/t/tools/ops2pm/samples/core_ops.original Mon Sep 7 00:17:23 2009 (r41087)
+++ branches/gc-refactor/t/tools/ops2pm/samples/core_ops.original Mon Sep 7 01:02:27 2009 (r41088)
@@ -1122,7 +1122,7 @@
if ($1)
Parrot_do_dod_run(interp, 0);
else
- if (interp->arena_base->num_early_DOD_PMCs)
+ if (interp->mem_pools->num_early_DOD_PMCs)
Parrot_do_dod_run(interp, GC_lazy_FLAG);
}
@@ -1185,7 +1185,7 @@
op needs_destroy(invar PMC) {
PObj_needs_early_DOD_SET($1);
- ++interp->arena_base->num_early_DOD_PMCs;
+ ++interp->mem_pools->num_early_DOD_PMCs;
}
=back
More information about the parrot-commits
mailing list