emacs: src/alloc.c comparison

comparison src/alloc.c @ 90068:eac554634bfa

Revision: miles@gnu.org--gnu-2004/emacs--unicode--0--patch-79 Merge from emacs--cvs-trunk--0 Patches applied: * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-735 - miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-747 Update from CVS

author	Miles Bader <miles@gnu.org>
date	Sat, 25 Dec 2004 02:00:25 +0000
parents	f2ebccfa87d4 0d2678a6add0
children	95879cc1ed20

comparison

equal deleted inserted replaced

-:b481c5870e10
+:eac554634bfa
 memory with malloc.
 If Emacs sets malloc hooks (! SYSTEM_MALLOC) and the emacs_blocked_*
 functions below are called from malloc, there is a chance that one
 of these threads preempts the Emacs main thread and the hook variables
-end up in a inconsistent state.  So we have a mutex to prevent that (note
+end up in an inconsistent state.  So we have a mutex to prevent that (note
 that the backend handles concurrent access to malloc within its own threads
 but Emacs code running in the main thread is not included in that control).
 When UNBLOCK_INPUT is called, revoke_input_signal may be called.  If this
 happens in one of the backend threads we will have two threads that tries
 to run Emacs code at once, and the code is not prepared for that.
 To prevent that, we only call BLOCK/UNBLOCK from the main thread.  */
 static pthread_mutex_t alloc_mutex;
-pthread_t main_thread;
 #define BLOCK_INPUT_ALLOC                       \
 do                                            \
 {                                           \
 pthread_mutex_lock (&alloc_mutex);        \
 #ifndef VIRT_ADDR_VARIES
 extern
 #endif /* VIRT_ADDR_VARIES */
 int malloc_sbrk_unused;
-/* Two limits controlling how much undo information to keep.  */
-EMACS_INT undo_limit;
-EMACS_INT undo_strong_limit;
-EMACS_INT undo_outer_limit;
 /* Number of live and free conses etc.  */
 static int total_conses, total_markers, total_symbols, total_vector_size;
 static int total_free_conses, total_free_markers, total_free_symbols;
 /*  GLIBC has a faster way to do this, but lets keep it portable.
 This is according to the Single UNIX Specification.  */
 pthread_mutexattr_init (&attr);
 pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
 pthread_mutex_init (&alloc_mutex, &attr);
-main_thread = pthread_self ();
 #endif /* HAVE_GTK_AND_PTHREAD */
 if (__free_hook != emacs_blocked_free)
 old_free_hook = __free_hook;
 __free_hook = emacs_blocked_free;
 EMACS_TIME t1, t2, t3;
 if (abort_on_gc)
 abort ();
-EMACS_GET_TIME (t1);
 /* Can't GC if pure storage overflowed because we can't determine
 if something is a pure object or not.  */
 if (pure_bytes_used_before_overflow)
 return Qnil;
+/* Don't keep undo information around forever.
+Do this early on, so it is no problem if the user quits.  */
+{
+register struct buffer *nextb = all_buffers;
+while (nextb)
+{
+	/* If a buffer's undo list is Qt, that means that undo is
+	   turned off in that buffer.  Calling truncate_undo_list on
+	   Qt tends to return NULL, which effectively turns undo back on.
+	   So don't call truncate_undo_list if undo_list is Qt.  */
+	if (! EQ (nextb->undo_list, Qt))
+	  truncate_undo_list (nextb);
+	/* Shrink buffer gaps, but skip indirect and dead buffers.  */
+	if (nextb->base_buffer == 0 && !NILP (nextb->name))
+	  {
+	    /* If a buffer's gap size is more than 10% of the buffer
+	       size, or larger than 2000 bytes, then shrink it
+	       accordingly.  Keep a minimum size of 20 bytes.  */
+	    int size = min (2000, max (20, (nextb->text->z_byte / 10)));
+	    if (nextb->text->gap_size > size)
+	      {
+		struct buffer *save_current = current_buffer;
+		current_buffer = nextb;
+		make_gap (-(nextb->text->gap_size - size));
+		current_buffer = save_current;
+	      }
+	  }
+	nextb = nextb->next;
+}
+}
+EMACS_GET_TIME (t1);
 /* In case user calls debug_print during GC,
 don't let that cause a recursive GC.  */
 consing_since_gc = 0;
 message1_nolog ("Garbage collecting...");
 BLOCK_INPUT;
 shrink_regexp_cache ();
-/* Don't keep undo information around forever.  */
-{
-register struct buffer *nextb = all_buffers;
-while (nextb)
-{
-	/* If a buffer's undo list is Qt, that means that undo is
-	   turned off in that buffer.  Calling truncate_undo_list on
-	   Qt tends to return NULL, which effectively turns undo back on.
-	   So don't call truncate_undo_list if undo_list is Qt.  */
-	if (! EQ (nextb->undo_list, Qt))
-	  nextb->undo_list
-	    = truncate_undo_list (nextb->undo_list, undo_limit,
-				  undo_strong_limit, undo_outer_limit);
-	/* Shrink buffer gaps, but skip indirect and dead buffers.  */
-	if (nextb->base_buffer == 0 && !NILP (nextb->name))
-	  {
-	    /* If a buffer's gap size is more than 10% of the buffer
-	       size, or larger than 2000 bytes, then shrink it
-	       accordingly.  Keep a minimum size of 20 bytes.  */
-	    int size = min (2000, max (20, (nextb->text->z_byte / 10)));
-	    if (nextb->text->gap_size > size)
-	      {
-		struct buffer *save_current = current_buffer;
-		current_buffer = nextb;
-		make_gap (-(nextb->text->gap_size - size));
-		current_buffer = save_current;
-	      }
-	  }
-	nextb = nextb->next;
-}
-}
 gc_in_progress = 1;
 /* clear_marks (); */
 DEFVAR_LISP ("purify-flag", &Vpurify_flag,
 	       doc: /* Non-nil means loading Lisp code in order to dump an executable.
 This means that certain objects should be allocated in shared (pure) space.  */);
-DEFVAR_INT ("undo-limit", &undo_limit,
-	      doc: /* Keep no more undo information once it exceeds this size.
-This limit is applied when garbage collection happens.
-The size is counted as the number of bytes occupied,
-which includes both saved text and other data.  */);
-undo_limit = 20000;
-DEFVAR_INT ("undo-strong-limit", &undo_strong_limit,
-	      doc: /* Don't keep more than this much size of undo information.
-A previous command which pushes the undo list past this size
-is entirely forgotten when GC happens.
-The size is counted as the number of bytes occupied,
-which includes both saved text and other data.  */);
-undo_strong_limit = 30000;
-DEFVAR_INT ("undo-outer-limit", &undo_outer_limit,
-	      doc: /* Don't keep more than this much size of undo information.
-If the current command has produced more than this much undo information,
-GC discards it.  This is a last-ditch limit to prevent memory overflow.
-The size is counted as the number of bytes occupied,
-which includes both saved text and other data.  */);
-undo_outer_limit = 300000;
 DEFVAR_BOOL ("garbage-collection-messages", &garbage_collection_messages,
 	       doc: /* Non-nil means display messages at start and end of garbage collection.  */);
 garbage_collection_messages = 0;
 DEFVAR_LISP ("post-gc-hook", &Vpost_gc_hook,

Mercurial > emacs

comparison src/alloc.c @ 90068:eac554634bfa