[svn:parrot] r36629 - in trunk/src: . call pmc

cotto at svn.parrot.org cotto at svn.parrot.org
Thu Feb 12 12:18:46 UTC 2009


Author: cotto
Date: Thu Feb 12 12:18:43 2009
New Revision: 36629
URL: https://trac.parrot.org/parrot/changeset/36629

Log:
[gc] replace/remove "DOD" in comments in most files in src/

Modified:
   trunk/src/call/pcc.c
   trunk/src/dynext.c
   trunk/src/embed.c
   trunk/src/exit.c
   trunk/src/extend.c
   trunk/src/hash.c
   trunk/src/hll.c
   trunk/src/inter_cb.c
   trunk/src/inter_create.c
   trunk/src/oo.c
   trunk/src/packfile.c
   trunk/src/pmc.c
   trunk/src/pmc/task.pmc
   trunk/src/pmc_freeze.c
   trunk/src/stacks.c
   trunk/src/thread.c

Modified: trunk/src/call/pcc.c
==============================================================================
--- trunk/src/call/pcc.c	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/call/pcc.c	Thu Feb 12 12:18:43 2009	(r36629)
@@ -1881,7 +1881,7 @@
 
     Parrot_process_args(interp, &st, param_or_result);
 
-    /* If we created a slurpy, we had to DOD register it so it did not get
+    /* If we created a slurpy, we had to GC register it so it did not get
      * collected during arg processing; we'll now unregister it. */
 }
 

Modified: trunk/src/dynext.c
==============================================================================
--- trunk/src/dynext.c	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/dynext.c	Thu Feb 12 12:18:43 2009	(r36629)
@@ -384,7 +384,7 @@
 
     /*
      * work around gcc 3.3.3 and other problem with dynpmcs
-     * something during library loading doesn't stand a DOD run
+     * something during library loading doesn't stand a GC run
      */
     Parrot_block_GC_mark(interp);
 

Modified: trunk/src/embed.c
==============================================================================
--- trunk/src/embed.c	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/embed.c	Thu Feb 12 12:18:43 2009	(r36629)
@@ -113,10 +113,10 @@
 Initializes the new interpreter when it hasn't been initialized before.
 
 Additionally sets the stack top, so that Parrot objects created
-in inner stack frames will be visible during DODs stack walking code.
+in inner stack frames will be visible during GC stack walking code.
 B<stack_top> should be the address of an automatic variable in the caller's
 stack frame. All unanchored Parrot objects (PMCs) must live in inner stack
-frames so that they are not destroyed during DOD runs.
+frames so that they are not destroyed during GC runs.
 
 Use this function when you call into Parrot before entering a run loop.
 

Modified: trunk/src/exit.c
==============================================================================
--- trunk/src/exit.c	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/exit.c	Thu Feb 12 12:18:43 2009	(r36629)
@@ -71,7 +71,7 @@
     /* call all the exit handlers */
     /* we are well "below" the runloop now, where lo_var_ptr
      * is set usually - exit handlers may run some resource-hungry
-     * stuff like printing profile stats - a DOD run would kill
+     * stuff like printing profile stats - a GC run would kill
      * resources - RT#46405 reset stacktop or better disable GC
      */
     /*

Modified: trunk/src/extend.c
==============================================================================
--- trunk/src/extend.c	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/extend.c	Thu Feb 12 12:18:43 2009	(r36629)
@@ -26,7 +26,7 @@
 */
 
 /* Some internal notes. Parrot will die a horrible and bizarre death
-   if the stack start pointer's not set and a DOD run is
+   if the stack start pointer's not set and a GC run is
    triggered. The pointer *will* be set by the interpreter if the
    interpreter calls code which calls these functions, so most
    extension code is safe, no problem.
@@ -1297,9 +1297,8 @@
 
 =item C<void Parrot_register_pmc>
 
-Add a reference of the PMC to the interpreters DOD registry. This
-prevents PMCs only known to extension from getting destroyed during DOD
-runs.
+Add a reference of the PMC to the interpreter's GC registry. This prevents PMCs
+only known to extension from getting destroyed during GC runs.
 
 =cut
 
@@ -1319,9 +1318,8 @@
 
 =item C<void Parrot_unregister_pmc>
 
-Remove a reference of the PMC from the interpreters DOD registry. If the
-reference count reaches zero, the PMC will be destroyed during the next
-DOD run.
+Remove a reference of the PMC from the interpreter's GC registry. If the
+reference count reaches zero, the PMC will be destroyed during the next GC run.
 
 =cut
 

Modified: trunk/src/hash.c
==============================================================================
--- trunk/src/hash.c	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/hash.c	Thu Feb 12 12:18:43 2009	(r36629)
@@ -1054,7 +1054,7 @@
 FIXME: This function can go back to just returning the hash struct
 pointer once Buffers can define their own custom mark routines.
 
-The problem is: During DODs stack walking the item on the stack must be
+The problem is: During GC stack walking the item on the stack must be
 a PMC. When an auto C<Hash*> is seen, it doesn't get properly marked
 (only the C<Hash*> buffer is marked, not its contents). By passing the
 C<**hptr> up to the Hash's init function, the newly constructed PMC is

Modified: trunk/src/hll.c
==============================================================================
--- trunk/src/hll.c	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/hll.c	Thu Feb 12 12:18:43 2009	(r36629)
@@ -90,7 +90,7 @@
     /*
      * ATT: all items that are owned by the HLL_info structure
      *      have to be created as constant objects, because
-     *      this structure isn't marked by DOD/GC
+     *      this structure isn't marked by GC
      */
     PMC * const entry = constant_pmc_new(interp, enum_class_FixedPMCArray);
 

Modified: trunk/src/inter_cb.c
==============================================================================
--- trunk/src/inter_cb.c	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/inter_cb.c	Thu Feb 12 12:18:43 2009	(r36629)
@@ -121,7 +121,7 @@
      * We are going to be passing the user_data PMC to external code, but
      * it may go out of scope until the callback is called -- we don't know
      * for certain as we don't know when the callback will be called.
-     * Therefore, to prevent the PMC from being destroyed by a DOD sweep,
+     * Therefore, to prevent the PMC from being destroyed by a GC sweep,
      * we need to anchor it.
      *
      */

Modified: trunk/src/inter_create.c
==============================================================================
--- trunk/src/inter_create.c	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/inter_create.c	Thu Feb 12 12:18:43 2009	(r36629)
@@ -250,7 +250,7 @@
     /* Done. Return and be done with it */
 
     /* Okay, we've finished doing anything that might trigger GC.
-     * Actually, we could enable DOD/GC earlier, but here all setup is
+     * Actually, we could enable GC earlier, but here all setup is
      * done
      */
     Parrot_unblock_GC_mark(interp);
@@ -331,7 +331,7 @@
      * Be sure that an async collector hasn't live bits set now, so
      * trigger a finish run
      *
-     * Need to turn off DOD blocking, else things stay alive and IO
+     * Need to turn off GC blocking, else things stay alive and IO
      * handles aren't closed
      */
     interp->arena_base->gc_mark_block_level  = 0;
@@ -344,7 +344,7 @@
     }
 
     /* Destroys all PMCs, even constants and the FileHandle objects for
-     * std{in, out, err}, so don't be verbose about DOD'ing. */
+     * std{in, out, err}, so don't be verbose about GC'ing. */
     if (interp->thread_data)
         interp->thread_data->state |= THREAD_STATE_SUSPENDED_GC;
 

Modified: trunk/src/oo.c
==============================================================================
--- trunk/src/oo.c	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/oo.c	Thu Feb 12 12:18:43 2009	(r36629)
@@ -745,7 +745,7 @@
  * quick'n'dirty method cache
  * RT #45987: use a hash if method_name is not constant
  *       i.e. from obj.$Sreg(args)
- *       If this hash is implemented mark it during DOD
+ *       If this hash is implemented mark it during GC
  */
 
 /*

Modified: trunk/src/packfile.c
==============================================================================
--- trunk/src/packfile.c	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/packfile.c	Thu Feb 12 12:18:43 2009	(r36629)
@@ -3617,7 +3617,7 @@
 
 Delete the C<PackFile_Constant> C<self>.
 
-Don't delete C<PMC>s or C<STRING>s, they are destroyed via DOD/GC.
+Don't delete C<PMC>s or C<STRING>s, they are destroyed via GC.
 
 =cut
 
@@ -3785,7 +3785,7 @@
     /*
      * TODO use thaw_constants
      * current issue: a constant Sub with attached properties
-     *                doesn't DOD mark the properties
+     *                doesn't GC mark the properties
      * for a constant PMC *all* contents have to be in the constant pools
      */
     pmc = Parrot_thaw(interp, image);

Modified: trunk/src/pmc.c
==============================================================================
--- trunk/src/pmc.c	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/pmc.c	Thu Feb 12 12:18:43 2009	(r36629)
@@ -755,7 +755,7 @@
 
 =item C<void gc_register_pmc>
 
-Registers the PMC with the interpreter's DOD registry.
+Registers the PMC with the interpreter's GC registry.
 
 =cut
 
@@ -766,7 +766,7 @@
 gc_register_pmc(PARROT_INTERP, ARGIN(PMC *pmc))
 {
     ASSERT_ARGS(gc_register_pmc)
-    /* Better not trigger a DOD run with a potentially unanchored PMC */
+    /* Better not trigger a GC run with a potentially unanchored PMC */
     Parrot_block_GC_mark(interp);
 
     PARROT_ASSERT(interp->gc_registry);
@@ -780,7 +780,7 @@
 
 =item C<void gc_unregister_pmc>
 
-Unregisters the PMC from the interpreter's DOD registry.
+Unregisters the PMC from the interpreter's GC registry.
 
 =cut
 

Modified: trunk/src/pmc/task.pmc
==============================================================================
--- trunk/src/pmc/task.pmc	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/pmc/task.pmc	Thu Feb 12 12:18:43 2009	(r36629)
@@ -126,7 +126,7 @@
 
         core_struct = mem_allocate_zeroed_typed(Parrot_Task_attributes);
 
-        /* Set flags for custom DOD mark and destroy. */
+        /* Set flags for custom GC mark and destroy. */
         PObj_custom_mark_SET(SELF);
         PObj_active_destroy_SET(SELF);
 

Modified: trunk/src/pmc_freeze.c
==============================================================================
--- trunk/src/pmc_freeze.c	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/pmc_freeze.c	Thu Feb 12 12:18:43 2009	(r36629)
@@ -445,8 +445,8 @@
 /* normal freeze can use next_for_GC ptrs or a seen hash */
 #define FREEZE_USE_NEXT_FOR_GC 0
 
-/* when thawing a string longer then this size, we first do a DOD run and then
- * block DOD/GC - the system can't give us more headers */
+/* when thawing a string longer then this size, we first do a GC run and then
+ * block GC - the system can't give us more headers */
 
 #define THAW_BLOCK_DOD_SIZE 100000
 
@@ -1829,8 +1829,8 @@
     info.image = image;
     /*
      * if we are thawing a lot of PMCs, its cheaper to do
-     * a DOD run first and then block DOD - the limit should be
-     * chosen so that no more then one DOD run would be triggered
+     * a GC run first and then block GC - the limit should be
+     * chosen so that no more then one GC run would be triggered
      *
      * XXX
      *
@@ -1885,7 +1885,7 @@
 
 This function must not consume any resources (except the image itself).
 It uses the C<next_for_GC> pointer, so its not reentrant and must not be
-interrupted by a DOD run.
+interrupted by a GC run.
 
 =cut
 
@@ -1938,7 +1938,7 @@
 #if FREEZE_USE_NEXT_FOR_GC
     ASSERT_ARGS(Parrot_freeze)
     /*
-     * we could do a DOD run here before, to free resources
+     * we could do a GC run here before, to free resources
      */
     return Parrot_freeze_at_destruct(interp, pmc);
 #else

Modified: trunk/src/stacks.c
==============================================================================
--- trunk/src/stacks.c	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/stacks.c	Thu Feb 12 12:18:43 2009	(r36629)
@@ -118,7 +118,7 @@
 
 =item C<void mark_stack>
 
-Mark entries in a stack structure during DOD.
+Mark entries in a stack structure during GC.
 
 =cut
 

Modified: trunk/src/thread.c
==============================================================================
--- trunk/src/thread.c	Thu Feb 12 11:49:30 2009	(r36628)
+++ trunk/src/thread.c	Thu Feb 12 12:18:43 2009	(r36629)
@@ -1332,16 +1332,16 @@
         if (retval) {
             PMC *parent_ret;
             /*
-             * clone the PMC into caller, if its not a shared PMC
+             * clone the PMC into caller, if it's not a shared PMC
              * the PMC is not in the parents root set nor in the
-             * stack so block DOD during clone
+             * stack so block GC during clone
              * XXX should probably acquire the parent's interpreter mutex
              */
             Parrot_block_GC_mark(parent);
             parent_ret = make_local_copy(parent, interp, retval);
 
             /* this PMC is living only in the stack of this currently
-             * dying interpreter, so register it in parent's DOD registry
+             * dying interpreter, so register it in parent's GC registry
              * XXX is this still needed?
              */
             gc_register_pmc(parent, parent_ret);
@@ -1590,20 +1590,20 @@
 
 =back
 
-=head2 DOD Synchronization Functions
+=head2 GC Synchronization Functions
 
 =over 4
 
 =item C<void pt_gc_start_mark>
 
-Record that the mark phase of DOD is about to begin. In the presence of shared
-PMCs, we can only run one DOD run at a time because C<< PMC->next_for_GC >> may
+Record that the mark phase of GC is about to begin. In the presence of shared
+PMCs, we can only run one GC run at a time because C<< PMC->next_for_GC >> may
 be changed.
 
-C<flags> are the DOD flags. We check if we need to collect shared objects or
+C<flags> are the GC flags. We check if we need to collect shared objects or
 not.
 
-TODO - Have a count of shared PMCs and check it during DOD.
+TODO - Have a count of shared PMCs and check it during GC.
 
 TODO - Evaluate if a interpreter lock is cheaper when C<gc_mark_ptr> is
 updated.
@@ -1673,7 +1673,7 @@
 
     DEBUG_ONLY(fprintf(stderr, "actually mark\n"));
     /*
-     * we can't allow parallel running DODs both would mess with shared PMCs
+     * We can't allow parallel running GCs; both would mess with shared PMCs'
      * next_for_GC pointers
      */
     LOCK(interpreter_array_mutex);
@@ -1684,7 +1684,7 @@
 
 =item C<void pt_gc_mark_root_finished>
 
-Records that DOD has finished for the root set.  EXCEPTION_UNIMPLEMENTED
+Records that GC has finished for the root set.  EXCEPTION_UNIMPLEMENTED
 
 =cut
 
@@ -1699,7 +1699,7 @@
     /*
      * TODO now check, if we are the owner of a shared memory pool
      * if yes:
-     * - now run DOD_mark on all members of our pool
+     * - now mark all members of our pool
      * - if all shared PMCs are marked by all threads then
      *   - we can continue to free unused objects
      */
@@ -1709,7 +1709,7 @@
 
 =item C<void pt_gc_stop_mark>
 
-Records that the mark phase of DOD has completed.
+Records that the mark phase of GC has completed.
 
 =cut
 
@@ -1751,7 +1751,7 @@
 
 =item C<void Parrot_shared_gc_block>
 
-Blocks stop-the-world DOD runs.
+Blocks stop-the-world GC runs.
 
 =cut
 
@@ -1775,7 +1775,7 @@
 
 =item C<void Parrot_shared_gc_unblock>
 
-Unblocks stop-the-world DOD runs.
+Unblocks stop-the-world GC runs.
 
 =cut
 


More information about the parrot-commits mailing list