xemacs-beta: src/alloc.c comparison

comparison src/alloc.c @ 3263:d674024a8674

[xemacs-hg @ 2006-02-27 16:29:00 by crestani] - Introduce a fancy asynchronous finalization strategy on C level. - Merge the code conditioned on MC_ALLOC into the code conditioned on NEW_GC. - Remove the possibility to free objects manually outside garbage collections when the new collector is enabled.

author	crestani
date	Mon, 27 Feb 2006 16:29:29 +0000
parents	1c2a4e4e81d9
children	73051095a712

comparison

equal deleted inserted replaced

-:79d41cfd8e6b
+:d674024a8674
 /* Very cheesy ways of figuring out how much memory is being used for
 data. #### Need better (system-dependent) ways. */
 void *minimum_address_seen;
 void *maximum_address_seen;
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 int
 c_readonly (Lisp_Object obj)
 {
 return POINTER_TYPE_P (XTYPE (obj)) && C_READONLY (obj);
 }
-#endif /* MC_ALLOC */
+#endif /* not NEW_GC */
 int
 lisp_readonly (Lisp_Object obj)
 {
 return POINTER_TYPE_P (XTYPE (obj)) && LISP_READONLY (obj);
 /* Non-zero means ignore malloc warnings.  Set during initialization.  */
 int ignore_malloc_warnings;
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 void *breathing_space;
 void
 release_breathing_space (void)
 {
 void *tmp = breathing_space;
 breathing_space = 0;
 xfree (tmp, void *);
 }
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 /* malloc calls this if it finds we are near exhausting storage */
 void
 malloc_warning (const char *str)
 {
 It's better to loop garbage-collecting (we might reclaim enough
 to win) than to loop beeping and barfing "Memory exhausted"
 */
 consing_since_gc = gc_cons_threshold + 1;
 recompute_need_to_garbage_collect ();
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 release_breathing_space ();
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 /* Flush some histories which might conceivably contain garbalogical
 inhibitors.  */
 if (!NILP (Fboundp (Qvalues)))
 Fset (Qvalues, Qnil);
 assert (!regex_malloc_disallowed);		\
 in_malloc = 1;				\
 }						\
 while (0)
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 #define FREE_OR_REALLOC_BEGIN(block)					\
 do									\
 {									\
 /* Unbelievably, calling free() on 0xDEADBEEF doesn't cause an	\
 error until much later on for many system mallocs, such as		\
 the one that comes with Solaris 2.3.  FMH!! */			\
 assert (block != (void *) 0xDEADBEEF);				\
 MALLOC_BEGIN ();							\
 }									\
 while (0)
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 #define FREE_OR_REALLOC_BEGIN(block)					\
 do									\
 {									\
 /* Unbelievably, calling free() on 0xDEADBEEF doesn't cause an	\
 error until much later on for many system mallocs, such as		\
 DUMPEDP. */							\
 assert (!DUMPEDP (block));						\
 MALLOC_BEGIN ();							\
 }									\
 while (0)
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 #define MALLOC_END()				\
 do						\
 {						\
 in_malloc = 0;				\
 MALLOC_END ();
 }
 #ifdef ERROR_CHECK_GC
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void
 deadbeef_memory (void *ptr, Bytecount size)
 {
 UINT_32_BIT *ptr4 = (UINT_32_BIT *) ptr;
 Bytecount beefs = size >> 2;
 /* In practice, size will always be a multiple of four.  */
 while (beefs--)
 (*ptr4++) = 0xDEADBEEF; /* -559038737 base 10 */
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 #else /* !ERROR_CHECK_GC */
 #define deadbeef_memory(ptr, size)
 return xstrdup (s);
 }
 #endif /* NEED_STRDUP */
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void *
 allocate_lisp_storage (Bytecount size)
 {
 void *val = xmalloc (size);
 /* We don't increment the cons counter anymore.  Calling functions do
 if (need_to_check_c_alloca)
 xemacs_c_alloca (0);
 return val;
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
-#if defined (MC_ALLOC) && defined (ALLOC_TYPE_STATS)
+#if defined (NEW_GC) && defined (ALLOC_TYPE_STATS)
 static struct
 {
 int instances_in_use;
 int bytes_in_use;
 int bytes_in_use_including_overhead;
 for (i = 0; i < (countof (lrecord_implementations_table)
 		   + MODULE_DEFINABLE_TYPE_COUNT); i++)
 size += lrecord_stats[i].bytes_in_use;
 return size;
 }
-#endif /* not (MC_ALLOC && ALLOC_TYPE_STATS) */
+#endif /* NEW_GC && ALLOC_TYPE_STATS */
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 /* lcrecords are chained together through their "next" field.
 After doing the mark phase, GC will walk this linked list
 and free any lcrecord which hasn't been marked. */
 static struct old_lcrecord_header *all_lcrecords;
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 /* The basic lrecord allocation functions. See lrecord.h for details. */
 void *
 alloc_lrecord (Bytecount size,
 	       const struct lrecord_implementation *implementation)
 {
 gc_checking_assert (LRECORD_FREE_P (lheader));
 set_lheader_implementation (lheader, implementation);
 #ifdef ALLOC_TYPE_STATS
 inc_lrecord_stats (size, lheader);
 #endif /* ALLOC_TYPE_STATS */
+if (implementation->finalizer)
+add_finalizable_obj (wrap_pointer_1 (lheader));
 INCREMENT_CONS_COUNTER (size, implementation->name);
 return lheader;
 }
 gc_checking_assert (LRECORD_FREE_P (lheader));
 set_lheader_implementation (lheader, implementation);
 #ifdef ALLOC_TYPE_STATS
 inc_lrecord_stats (size, lheader);
 #endif /* ALLOC_TYPE_STATS */
+if (implementation->finalizer)
+add_finalizable_obj (wrap_pointer_1 (lheader));
 NOSEEUM_INCREMENT_CONS_COUNTER (size, implementation->name);
 return lheader;
 }
-#ifdef NEW_GC
 void *
 alloc_lrecord_array (Bytecount size, int elemcount,
 		     const struct lrecord_implementation *implementation)
 {
 struct lrecord_header *lheader;
 set_lheader_implementation (lh, implementation);
 lh->uid = lrecord_uid_counter++;
 #ifdef ALLOC_TYPE_STATS
 inc_lrecord_stats (size, lh);
 #endif /* not ALLOC_TYPE_STATS */
+if (implementation->finalizer)
+	add_finalizable_obj (wrap_pointer_1 (lh));
 }
 INCREMENT_CONS_COUNTER (size * elemcount, implementation->name);
 return lheader;
 }
-#endif /* NEW_GC */
 void
-free_lrecord (Lisp_Object lrecord)
+free_lrecord (Lisp_Object UNUSED (lrecord))
 {
-#ifndef NEW_GC
+/* Manual frees are not allowed with asynchronous finalization */
-gc_checking_assert (!gc_in_progress);
+return;
-#endif /* not NEW_GC */
+}
-gc_checking_assert (!LRECORD_FREE_P (XRECORD_LHEADER (lrecord)));
+#else /* not NEW_GC */
-gc_checking_assert (!XRECORD_LHEADER (lrecord)->free);
-#ifdef NEW_GC
-GC_STAT_EXPLICITLY_TRIED_FREED;
-/* Ignore requests to manual free objects while in garbage collection. */
-if (write_barrier_enabled || gc_in_progress)
-return;
-GC_STAT_EXPLICITLY_FREED;
-#endif /* NEW_GC */
-MC_ALLOC_CALL_FINALIZER (XPNTR (lrecord));
-mc_free (XPNTR (lrecord));
-recompute_need_to_garbage_collect ();
-}
-#else /* not MC_ALLOC */
 /* The most basic of the lcrecord allocation functions.  Not usually called
 directly.  Allocates an lrecord not managed by any lcrecord-list, of a
 specified size.  See lrecord.h. */
 lrecord->implementation->finalizer (lrecord, 0);
 xfree (lrecord);
 return;
 }
 #endif /* Unused */
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 static void
 disksave_object_finalization_1 (void)
 {
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 mc_finalize_for_disksave ();
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 struct old_lcrecord_header *header;
 for (header = all_lcrecords; header; header = header->next)
 {
 if (LHEADER_IMPLEMENTATION (&header->lheader)->finalizer &&
 	  !header->free)
 	LHEADER_IMPLEMENTATION (&header->lheader)->finalizer (header, 1);
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
 /* Bitwise copy all parts of a Lisp object other than the header */
 void
 Bytecount size = lisp_object_size (src);
 assert (imp == XRECORD_LHEADER_IMPLEMENTATION (dst));
 assert (size == lisp_object_size (dst));
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 memcpy ((char *) XRECORD_LHEADER (dst) + sizeof (struct lrecord_header),
 	  (char *) XRECORD_LHEADER (src) + sizeof (struct lrecord_header),
 	  size - sizeof (struct lrecord_header));
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 if (imp->basic_p)
 memcpy ((char *) XRECORD_LHEADER (dst) + sizeof (struct lrecord_header),
 	    (char *) XRECORD_LHEADER (src) + sizeof (struct lrecord_header),
 	    size - sizeof (struct lrecord_header));
 else
 memcpy ((char *) XRECORD_LHEADER (dst) +
 	    sizeof (struct old_lcrecord_header),
 	    (char *) XRECORD_LHEADER (src) +
 	    sizeof (struct old_lcrecord_header),
 	    size - sizeof (struct old_lcrecord_header));
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
 /************************************************************************/
 /*			  Debugger support				*/
 {
 return EQ (obj1, obj2);
 }
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 #define DECLARE_FIXED_TYPE_ALLOC(type, structture) struct __foo__
 #else
 /************************************************************************/
 /*			  Fixed-size type macros			*/
 /************************************************************************/
 gc_count_num_##type##_freelist++;				\
 } while (0)
 #else
 #define FREE_FIXED_TYPE_WHEN_NOT_IN_GC(type, structtype, ptr)
 #endif
-#endif /* not MC_ALLOC */
+#endif /* NEW_GC */
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 #define ALLOCATE_FIXED_TYPE_AND_SET_IMPL(type, lisp_type, var, lrec_ptr) \
 do {									\
 (var) = alloc_lrecord_type (lisp_type, lrec_ptr);			\
 } while (0)
 #define NOSEEUM_ALLOCATE_FIXED_TYPE_AND_SET_IMPL(type, lisp_type, var,	\
 lrec_ptr)		\
 do {									\
 (var) = noseeum_alloc_lrecord_type (lisp_type, lrec_ptr);		\
 } while (0)
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 #define ALLOCATE_FIXED_TYPE_AND_SET_IMPL(type, lisp_type, var, lrec_ptr) \
 do									\
 {									\
 ALLOCATE_FIXED_TYPE (type, lisp_type, var);				\
 set_lheader_implementation (&(var)->lheader, lrec_ptr);		\
 do									\
 {									\
 NOSEEUM_ALLOCATE_FIXED_TYPE (type, lisp_type, var);			\
 set_lheader_implementation (&(var)->lheader, lrec_ptr);		\
 } while (0)
-#endif /* MC_ALLOC */
+#endif /* not NEW_GC */
 /************************************************************************/
 /*			   Cons allocation				*/
 string_plist (Lisp_Object string)
 {
 return *string_plist_ptr (string);
 }
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 /* No `finalize', or `hash' methods.
 internal_hash() already knows how to hash strings and finalization
 is done with the ADDITIONAL_FREE_string macro, which is the
 standard way to do finalization when using
 SWEEP_FIXED_TYPE_BLOCK(). */
 						string_getprop,
 						string_putprop,
 						string_remprop,
 						string_plist,
 						Lisp_String);
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 #ifdef NEW_GC
 #define STRING_FULLSIZE(size) \
 ALIGN_SIZE (FLEXIBLE_ARRAY_STRUCT_SIZEOF (Lisp_String_Direct_Data, Lisp_Object, data, (size) + 1), sizeof (Lisp_Object *));
 #else /* not NEW_GC */
 #define STRING_CHARS_FREE_P(ptr) ((ptr)->string == NULL)
 #define MARK_STRING_CHARS_AS_FREE(ptr) ((void) ((ptr)->string = NULL))
 #endif /* not NEW_GC */
-#ifdef MC_ALLOC
+#ifdef NEW_GC
-#ifndef NEW_GC
-static void
-finalize_string (void *header, int for_disksave)
-{
-if (!for_disksave)
-{
-Lisp_String *s = (Lisp_String *) header;
-Bytecount size = s->size_;
-if (BIG_STRING_SIZE_P (size))
-	xfree (s->data_, Ibyte *);
-}
-}
-DEFINE_LRECORD_IMPLEMENTATION_WITH_PROPS ("string", string,
-					  1, /*dumpable-flag*/
-					  mark_string, print_string,
-					  finalize_string,
-					  string_equal, 0,
-					  string_description,
-					  string_getprop,
-					  string_putprop,
-					  string_remprop,
-					  string_plist,
-					  Lisp_String);
-#else /* NEW_GC */
 DEFINE_LRECORD_IMPLEMENTATION_WITH_PROPS ("string", string,
 					  1, /*dumpable-flag*/
 					  mark_string, print_string,
 					  0,
 					  string_equal, 0,
 			       1, /*dumpable-flag*/
 			       0, 0, 0, 0, 0,
 			       string_indirect_data_description,
 			       Lisp_String_Indirect_Data);
 #endif /* NEW_GC */
-#endif /* MC_ALLOC */
 #ifndef NEW_GC
 struct string_chars
 {
 Lisp_String *string;
 Lisp_String *s;
 Bytecount fullsize = STRING_FULLSIZE (length);
 assert (length >= 0 && fullsize > 0);
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 s = alloc_lrecord_type (Lisp_String, &lrecord_string);
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 /* Allocate the string header */
 ALLOCATE_FIXED_TYPE (string, Lisp_String, s);
 xzero (*s);
 set_lheader_implementation (&s->u.lheader, &lrecord_string);
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 /* The above allocations set the UID field, which overlaps with the
 ascii-length field, to some non-zero value.  We need to zero it. */
 XSET_STRING_ASCII_BEGIN (wrap_string (s), 0);
 					 newfullsize));
 if (delta > 0 && pos >= 0)
 memmove (XSTRING_DATA (s) + pos + delta, XSTRING_DATA (s) + pos,
 	     len);
-#else /* NEW_GC */
+#else /* not NEW_GC */
 oldfullsize = STRING_FULLSIZE (XSTRING_LENGTH (s));
 newfullsize = STRING_FULLSIZE (XSTRING_LENGTH (s) + delta);
 if (BIG_STRING_FULLSIZE_P (oldfullsize))
 {
 /* Make sure we find out about bad make_string_nocopy's when they happen */
 #if defined (ERROR_CHECK_TEXT) && defined (MULE)
 bytecount_to_charcount (contents, length); /* Just for the assertions */
 #endif
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 s = alloc_lrecord_type (Lisp_String, &lrecord_string);
 mcpro (wrap_pointer_1 (s)); /* otherwise nocopy_strings get
 				 collected and static data is tried to
 				 be freed. */
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 /* Allocate the string header */
 ALLOCATE_FIXED_TYPE (string, Lisp_String, s);
 set_lheader_implementation (&s->u.lheader, &lrecord_string);
 SET_C_READONLY_RECORD_HEADER (&s->u.lheader);
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 /* Don't need to XSET_STRING_ASCII_BEGIN() here because it happens in
 init_string_ascii_begin(). */
 s->plist = Qnil;
 #ifdef NEW_GC
 set_lispstringp_indirect (s);
 return val;
 }
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 /************************************************************************/
 /*                           lcrecord lists                             */
 /************************************************************************/
 /* Lcrecord lists are used to manage the allocation of particular
 assert (!EQ (all_lcrecord_lists[type], Qzero));
 free_managed_lcrecord (all_lcrecord_lists[type], rec);
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 DEFUN ("purecopy", Fpurecopy, 1, 1, 0, /*
 Kept for compatibility, returns its argument.
 Old:
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 static const struct memory_description mcpro_description_1[] = {
 { XD_END }
 };
 static const struct sized_memory_description mcpro_description = {
 {
 Dynarr_add (mcpros, varaddress);
 }
 #endif /* not DEBUG_XEMACS */
-#endif /* MC_ALLOC */
+#endif /* NEW_GC */
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static int gc_count_num_short_string_in_use;
 static Bytecount gc_count_string_total_size;
 static Bytecount gc_count_short_string_total_size;
 /* static int gc_count_total_records_used, gc_count_records_total_size; */
 	  lcrecord_stats[type_index].instances_in_use++;
 	  lcrecord_stats[type_index].bytes_in_use += sz;
 	}
 }
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 /* Free all unmarked records */
 static void
 sweep_lcrecords_1 (struct old_lcrecord_header **prev, int *used)
 {
 struct old_lcrecord_header *header;
 #endif /* !ERROR_CHECK_GC */
 #define SWEEP_FIXED_TYPE_BLOCK(typename, obj_type) \
 SWEEP_FIXED_TYPE_BLOCK_1 (typename, obj_type, lheader)
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void
 sweep_conses (void)
 {
 #define UNMARK_cons(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
 #define ADDITIONAL_FREE_cons(ptr)
 SWEEP_FIXED_TYPE_BLOCK (cons, Lisp_Cons);
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 /* Explicitly free a cons cell.  */
 void
 free_cons (Lisp_Object cons)
 {
-#ifndef MC_ALLOC /* to avoid compiler warning */
+#ifndef NEW_GC /* to avoid compiler warning */
 Lisp_Cons *ptr = XCONS (cons);
-#endif /* MC_ALLOC */
+#endif /* not NEW_GC */
 #ifdef ERROR_CHECK_GC
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 Lisp_Cons *ptr = XCONS (cons);
-#endif /* MC_ALLOC */
+#endif /* NEW_GC */
 /* If the CAR is not an int, then it will be a pointer, which will
 always be four-byte aligned.  If this cons cell has already been
 placed on the free list, however, its car will probably contain
 a chain pointer to the next cons on the list, which has cleverly
 had all its 0's and 1's inverted.  This allows for a quick
 well as a check in FREE_FIXED_TYPE(). */
 if (POINTER_TYPE_P (XTYPE (cons_car (ptr))))
 ASSERT_VALID_POINTER (XPNTR (cons_car (ptr)));
 #endif /* ERROR_CHECK_GC */
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 free_lrecord (cons);
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 FREE_FIXED_TYPE_WHEN_NOT_IN_GC (cons, Lisp_Cons, ptr);
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
 /* explicitly free a list.  You **must make sure** that you have
 created all the cons cells that make up this list and that there
 are no pointers to any of these cons cells anywhere else.  If there
 free_cons (XCAR (rest));
 free_cons (rest);
 }
 }
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void
 sweep_compiled_functions (void)
 {
 #define UNMARK_compiled_function(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
 #define ADDITIONAL_FREE_compiled_function(ptr) \
 #define UNMARK_event(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
 #define ADDITIONAL_FREE_event(ptr)
 SWEEP_FIXED_TYPE_BLOCK (event, Lisp_Event);
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 #ifdef EVENT_DATA_AS_OBJECTS
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void
 sweep_key_data (void)
 {
 #define UNMARK_key_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
 #define ADDITIONAL_FREE_key_data(ptr)
 SWEEP_FIXED_TYPE_BLOCK (key_data, Lisp_Key_Data);
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 void
 free_key_data (Lisp_Object ptr)
 {
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 free_lrecord (ptr);
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 FREE_FIXED_TYPE_WHEN_NOT_IN_GC (key_data, Lisp_Key_Data, XKEY_DATA (ptr));
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void
 sweep_button_data (void)
 {
 #define UNMARK_button_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
 #define ADDITIONAL_FREE_button_data(ptr)
 SWEEP_FIXED_TYPE_BLOCK (button_data, Lisp_Button_Data);
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 void
 free_button_data (Lisp_Object ptr)
 {
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 free_lrecord (ptr);
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 FREE_FIXED_TYPE_WHEN_NOT_IN_GC (button_data, Lisp_Button_Data, XBUTTON_DATA (ptr));
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void
 sweep_motion_data (void)
 {
 #define UNMARK_motion_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
 #define ADDITIONAL_FREE_motion_data(ptr)
 SWEEP_FIXED_TYPE_BLOCK (motion_data, Lisp_Motion_Data);
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 void
 free_motion_data (Lisp_Object ptr)
 {
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 free_lrecord (ptr);
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 FREE_FIXED_TYPE_WHEN_NOT_IN_GC (motion_data, Lisp_Motion_Data, XMOTION_DATA (ptr));
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void
 sweep_process_data (void)
 {
 #define UNMARK_process_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
 #define ADDITIONAL_FREE_process_data(ptr)
 SWEEP_FIXED_TYPE_BLOCK (process_data, Lisp_Process_Data);
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 void
 free_process_data (Lisp_Object ptr)
 {
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 free_lrecord (ptr);
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 FREE_FIXED_TYPE_WHEN_NOT_IN_GC (process_data, Lisp_Process_Data, XPROCESS_DATA (ptr));
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void
 sweep_timeout_data (void)
 {
 #define UNMARK_timeout_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
 #define ADDITIONAL_FREE_timeout_data(ptr)
 SWEEP_FIXED_TYPE_BLOCK (timeout_data, Lisp_Timeout_Data);
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 void
 free_timeout_data (Lisp_Object ptr)
 {
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 free_lrecord (ptr);
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 FREE_FIXED_TYPE_WHEN_NOT_IN_GC (timeout_data, Lisp_Timeout_Data, XTIMEOUT_DATA (ptr));
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void
 sweep_magic_data (void)
 {
 #define UNMARK_magic_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
 #define ADDITIONAL_FREE_magic_data(ptr)
 SWEEP_FIXED_TYPE_BLOCK (magic_data, Lisp_Magic_Data);
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 void
 free_magic_data (Lisp_Object ptr)
 {
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 free_lrecord (ptr);
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 FREE_FIXED_TYPE_WHEN_NOT_IN_GC (magic_data, Lisp_Magic_Data, XMAGIC_DATA (ptr));
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void
 sweep_magic_eval_data (void)
 {
 #define UNMARK_magic_eval_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
 #define ADDITIONAL_FREE_magic_eval_data(ptr)
 SWEEP_FIXED_TYPE_BLOCK (magic_eval_data, Lisp_Magic_Eval_Data);
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 void
 free_magic_eval_data (Lisp_Object ptr)
 {
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 free_lrecord (ptr);
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 FREE_FIXED_TYPE_WHEN_NOT_IN_GC (magic_eval_data, Lisp_Magic_Eval_Data, XMAGIC_EVAL_DATA (ptr));
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void
 sweep_eval_data (void)
 {
 #define UNMARK_eval_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
 #define ADDITIONAL_FREE_eval_data(ptr)
 SWEEP_FIXED_TYPE_BLOCK (eval_data, Lisp_Eval_Data);
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 void
 free_eval_data (Lisp_Object ptr)
 {
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 free_lrecord (ptr);
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 FREE_FIXED_TYPE_WHEN_NOT_IN_GC (eval_data, Lisp_Eval_Data, XEVAL_DATA (ptr));
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void
 sweep_misc_user_data (void)
 {
 #define UNMARK_misc_user_data(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
 #define ADDITIONAL_FREE_misc_user_data(ptr)
 SWEEP_FIXED_TYPE_BLOCK (misc_user_data, Lisp_Misc_User_Data);
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 void
 free_misc_user_data (Lisp_Object ptr)
 {
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 free_lrecord (ptr);
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 FREE_FIXED_TYPE_WHEN_NOT_IN_GC (misc_user_data, Lisp_Misc_User_Data, XMISC_USER_DATA (ptr));
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
 #endif /* EVENT_DATA_AS_OBJECTS */
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void
 sweep_markers (void)
 {
 #define UNMARK_marker(ptr) UNMARK_RECORD_HEADER (&((ptr)->lheader))
 #define ADDITIONAL_FREE_marker(ptr)					\
 unchain_marker (tem);						\
 } while (0)
 SWEEP_FIXED_TYPE_BLOCK (marker, Lisp_Marker);
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 /* Explicitly free a marker.  */
 void
 free_marker (Lisp_Object ptr)
 {
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 free_lrecord (ptr);
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 FREE_FIXED_TYPE_WHEN_NOT_IN_GC (marker, Lisp_Marker, XMARKER (ptr));
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
 #if defined (MULE) && defined (VERIFY_STRING_CHARS_INTEGRITY)
 current_string_chars_block->next = 0;
 }
 }
 #endif /* not NEW_GC */
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 #if 1 /* Hack to debug missing purecopy's */
 static int debug_string_purity;
 static void
 debug_string_purity_print (Lisp_Object p)
 stderr_out ("%c", ch);
 }
 stderr_out ("\"\n");
 }
 #endif /* 1 */
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void
 sweep_strings (void)
 {
 int num_small_used = 0;
 Bytecount num_small_bytes = 0, num_bytes = 0;
 gc_count_num_short_string_in_use = num_small_used;
 gc_count_string_total_size = num_bytes;
 gc_count_short_string_total_size = num_small_bytes;
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 #ifndef NEW_GC
 void
 gc_sweep_1 (void)
 {
-#ifdef MC_ALLOC
-compact_string_chars ();
-mc_finalize ();
-mc_sweep ();
-#else /* not MC_ALLOC */
 /* Free all unmarked records.  Do this at the very beginning,
 before anything else, so that the finalize methods can safely
 examine items in the objects.  sweep_lcrecords_1() makes
 sure to call all the finalize methods *before* freeing anything,
 to complete the safety. */
 sweep_magic_data ();
 sweep_magic_eval_data ();
 sweep_eval_data ();
 sweep_misc_user_data ();
 #endif /* EVENT_DATA_AS_OBJECTS */
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 #ifdef PDUMP
 pdump_objects_unmark ();
 #endif
-#endif /* not MC_ALLOC */
 }
 #endif /* not NEW_GC */
 /* Clearing for disksave. */
 {
 Lisp_Object pl = Qnil;
 int i;
 EMACS_INT tgu_val = 0;
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 for (i = 0; i < (countof (lrecord_implementations_table)
 		   + MODULE_DEFINABLE_TYPE_COUNT); i++)
 {
 if (lrecord_stats[i].instances_in_use != 0)
 	    sprintf (buf, "%ss-used", name);
 	  pl = gc_plist_hack (buf, lrecord_stats[i].instances_in_use, pl);
 }
 }
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 #define HACK_O_MATIC(type, name, pl) do {				\
 EMACS_INT s = 0;							\
 struct type##_block *x = current_##type##_block;			\
 while (x) { s += sizeof (*x) + MALLOC_OVERHEAD; x = x->prev; }	\
 pl = gc_plist_hack ("conses-free", gc_count_num_cons_freelist, pl);
 pl = gc_plist_hack ("conses-used", gc_count_num_cons_in_use, pl);
 #undef HACK_O_MATIC
-#endif /* MC_ALLOC */
+#endif /* NEW_GC */
 if (set_total_gc_usage)
 {
 total_gc_usage = tgu_val;
 total_gc_usage_set = 1;
 /* This will get set to 1, and total_gc_usage computed, as part of the
 call to object_memory_usage_stats() -- if ALLOC_TYPE_STATS is enabled. */
 total_gc_usage_set = 0;
 #ifdef ALLOC_TYPE_STATS
 /* The things we do for backwards-compatibility */
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 return
 list6
 (Fcons (make_int (lrecord_stats[lrecord_type_cons].instances_in_use),
 	    make_int (lrecord_stats[lrecord_type_cons]
 		      .bytes_in_use_including_overhead)),
 make_int (lrecord_stats[lrecord_type_string]
 	       .bytes_in_use_including_overhead),
 make_int (lrecord_stats[lrecord_type_vector]
 	       .bytes_in_use_including_overhead),
 object_memory_usage_stats (1));
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 return
 list6 (Fcons (make_int (gc_count_num_cons_in_use),
 		  make_int (gc_count_num_cons_freelist)),
 	   Fcons (make_int (gc_count_num_symbol_in_use),
 		  make_int (gc_count_num_symbol_freelist)),
 		  make_int (gc_count_num_marker_freelist)),
 	   make_int (gc_count_string_total_size),
 	   make_int (lcrecord_stats[lrecord_type_vector].bytes_in_use +
 		     lcrecord_stats[lrecord_type_vector].bytes_freed),
 	   object_memory_usage_stats (1));
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 #else /* not ALLOC_TYPE_STATS */
 return Qnil;
 #endif /* ALLOC_TYPE_STATS */
 }
 stats->malloc_overhead += claimed_size - orig_claimed_size;
 }
 return claimed_size;
 }
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 Bytecount
 fixed_type_block_overhead (Bytecount size)
 {
 Bytecount per_block = TYPE_ALLOC_SIZE (cons, unsigned char);
 Bytecount overhead = 0;
 }
 if (rand () % per_block < size)
 overhead += sizeof (void *) + per_block - storage_size;
 return overhead;
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 #endif /* MEMORY_USAGE_STATS */
 /* Initialization */
 static void
 /* C guarantees that Qnull_pointer will be initialized to all 0 bits,
 so the following is actually a no-op.  */
 Qnull_pointer = wrap_pointer_1 (0);
 #endif
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 breathing_space = 0;
-#endif /* not MC_ALLOC */
-#ifndef MC_ALLOC
 all_lcrecords = 0;
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 ignore_malloc_warnings = 1;
 #ifdef DOUG_LEA_MALLOC
 mallopt (M_TRIM_THRESHOLD, 128*1024); /* trim threshold */
 mallopt (M_MMAP_THRESHOLD, 64*1024); /* mmap threshold */
 #if 0 /* Moved to emacs.c */
 mallopt (M_MMAP_MAX, 64); /* max. number of mmap'ed areas */
 #endif
 #endif
 #ifndef NEW_GC
 init_string_chars_alloc ();
-#endif /* not NEW_GC */
-#ifndef MC_ALLOC
 init_string_alloc ();
 init_string_chars_alloc ();
 init_cons_alloc ();
 init_symbol_alloc ();
 init_compiled_function_alloc ();
 init_magic_data_alloc ();
 init_magic_eval_data_alloc ();
 init_eval_data_alloc ();
 init_misc_user_data_alloc ();
 #endif /* EVENT_DATA_AS_OBJECTS */
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 ignore_malloc_warnings = 0;
 if (staticpros_nodump)
 Dynarr_free (staticpros_nodump);
 Dynarr_free (staticpro_nodump_names);
 staticpro_nodump_names = Dynarr_new2 (char_ptr_dynarr, char *);
 Dynarr_resize (staticpro_nodump_names, 100); /* ditto */
 #endif
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 mcpros = Dynarr_new2 (Lisp_Object_dynarr, Lisp_Object);
 Dynarr_resize (mcpros, 1410); /* merely a small optimization */
 dump_add_root_block_ptr (&mcpros, &mcpros_description);
 #ifdef DEBUG_XEMACS
 mcpro_names = Dynarr_new2 (char_ptr_dynarr, char *);
 Dynarr_resize (mcpro_names, 1410); /* merely a small optimization */
 dump_add_root_block_ptr (&mcpro_names, &mcpro_names_description);
 #endif
-#endif /* MC_ALLOC */
+#endif /* NEW_GC */
 consing_since_gc = 0;
 need_to_check_c_alloca = 0;
 funcall_allocation_flag = 0;
 funcall_alloca_count = 0;
 lrecord_uid_counter = 259;
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 debug_string_purity = 0;
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 #ifdef ERROR_CHECK_TYPES
 ERROR_ME.really_unlikely_name_to_have_accidentally_in_a_non_errb_structure =
 666;
 ERROR_ME_NOT.
 really_unlikely_name_to_have_accidentally_in_a_non_errb_structure =
 8675309;
 #endif /* ERROR_CHECK_TYPES */
 }
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 static void
 init_lcrecord_lists (void)
 {
 int i;
 {
 all_lcrecord_lists[i] = Qzero; /* Qnil not yet set */
 staticpro_nodump (&all_lcrecord_lists[i]);
 }
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 void
 init_alloc_early (void)
 {
 #if defined (__cplusplus) && defined (ERROR_CHECK_GC)
 void
 reinit_alloc_early (void)
 {
 common_init_alloc_early ();
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 init_lcrecord_lists ();
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
 void
 init_alloc_once_early (void)
 {
 INIT_LRECORD_IMPLEMENTATION (string);
 #ifdef NEW_GC
 INIT_LRECORD_IMPLEMENTATION (string_indirect_data);
 INIT_LRECORD_IMPLEMENTATION (string_direct_data);
 #endif /* NEW_GC */
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 INIT_LRECORD_IMPLEMENTATION (lcrecord_list);
 INIT_LRECORD_IMPLEMENTATION (free);
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 staticpros = Dynarr_new2 (Lisp_Object_ptr_dynarr, Lisp_Object *);
 Dynarr_resize (staticpros, 1410); /* merely a small optimization */
 dump_add_root_block_ptr (&staticpros, &staticpros_description);
 #ifdef DEBUG_XEMACS
 staticpro_names = Dynarr_new2 (char_ptr_dynarr, char *);
 Dynarr_resize (staticpro_names, 1410); /* merely a small optimization */
 dump_add_root_block_ptr (&staticpro_names, &staticpro_names_description);
 #endif
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 mcpros = Dynarr_new2 (Lisp_Object_dynarr, Lisp_Object);
 Dynarr_resize (mcpros, 1410); /* merely a small optimization */
 dump_add_root_block_ptr (&mcpros, &mcpros_description);
 #ifdef DEBUG_XEMACS
 mcpro_names = Dynarr_new2 (char_ptr_dynarr, char *);
 Dynarr_resize (mcpro_names, 1410); /* merely a small optimization */
 dump_add_root_block_ptr (&mcpro_names, &mcpro_names_description);
 #endif
-#endif /* MC_ALLOC */
+#else /* not NEW_GC */
-#ifndef MC_ALLOC
 init_lcrecord_lists ();
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
 void
 syms_of_alloc (void)
 {

Mercurial > hg > xemacs-beta

comparison src/alloc.c @ 3263:d674024a8674