emacs: src/alloc.c comparison

comparison src/alloc.c @ 51938:20d4eb1de9b0

Use bitmaps for cons cells, as was done for floats. (init_float, init_cons): Let the normal code allocate the first block. (CONS_BLOCK_SIZE): Redefine based on BLOCK_BYTES and bitmap size. (CONS_BLOCK, CONS_INDEX, CONS_MARKED_P, CONS_MARK, CONS_UNMARK): New macros. (struct cons_block): Move conses to the beginning. Add gcmarkbits. (Fcons): Use lisp_align_malloc and CONS_UNMARK. (live_cons_p): Check the pointer is not past the `conses' array. (mark_maybe_object, mark_maybe_pointer): Use CONS_MARKED_P. (mark_object, mark_buffer): Use CONS_MARKED_P and CONS_MARK. (survives_gc_p): Use CONS_MARKED_P and simplify. (gc_sweep): Use CONS_MARKED_P, CONS_UNMARK, and lisp_align_free.

author	Stefan Monnier <monnier@iro.umontreal.ca>
date	Tue, 15 Jul 2003 19:19:59 +0000
parents	cb3976b5e59f
children	111cc76606c6

comparison

equal deleted inserted replaced

-:2378c0aad975
+:20d4eb1de9b0
 /* Initialize float allocation.  */
 void
 init_float ()
 {
-float_block = (struct float_block *) lisp_align_malloc (sizeof *float_block,
+float_block = NULL;
-							  MEM_TYPE_FLOAT);
+float_block_index = FLOAT_BLOCK_SIZE; /* Force alloc of new float_block.   */
-float_block->next = 0;
-bzero ((char *) float_block->floats, sizeof float_block->floats);
-bzero ((char *) float_block->gcmarkbits, sizeof float_block->gcmarkbits);
-float_block_index = 0;
 float_free_list = 0;
-n_float_blocks = 1;
+n_float_blocks = 0;
 }
 /* Explicitly free a float cell by putting it on the free-list.  */
 ***********************************************************************/
 /* We store cons cells inside of cons_blocks, allocating a new
 cons_block with malloc whenever necessary.  Cons cells reclaimed by
 GC are put on a free list to be reallocated before allocating
-any new cons cells from the latest cons_block.
+any new cons cells from the latest cons_block.  */
-Each cons_block is just under 1020 bytes long,
-since malloc really allocates in units of powers of two
-and uses 4 bytes for its own overhead. */
 #define CONS_BLOCK_SIZE \
-((1020 - sizeof (struct cons_block *)) / sizeof (struct Lisp_Cons))
+(((BLOCK_BYTES - sizeof (struct cons_block *)) * CHAR_BIT) \
+/ (sizeof (struct Lisp_Cons) * CHAR_BIT + 1))
+#define CONS_BLOCK(fptr) \
+((struct cons_block *)(((EMACS_UINT)(fptr)) & ~(BLOCK_ALIGN - 1)))
+#define CONS_INDEX(fptr) \
+((((EMACS_UINT)(fptr)) & (BLOCK_ALIGN - 1)) / sizeof (struct Lisp_Cons))
 struct cons_block
 {
+/* Place `conses' at the beginning, to ease up CONS_INDEX's job.  */
+struct Lisp_Cons conses[CONS_BLOCK_SIZE];
+int gcmarkbits[1 + CONS_BLOCK_SIZE / (sizeof(int) * CHAR_BIT)];
 struct cons_block *next;
-struct Lisp_Cons conses[CONS_BLOCK_SIZE];
 };
+#define CONS_MARKED_P(fptr) \
+GETMARKBIT (CONS_BLOCK (fptr), CONS_INDEX ((fptr)))
+#define CONS_MARK(fptr) \
+SETMARKBIT (CONS_BLOCK (fptr), CONS_INDEX ((fptr)))
+#define CONS_UNMARK(fptr) \
+UNSETMARKBIT (CONS_BLOCK (fptr), CONS_INDEX ((fptr)))
 /* Current cons_block.  */
 struct cons_block *cons_block;
 /* Initialize cons allocation.  */
 void
 init_cons ()
 {
-cons_block = (struct cons_block *) lisp_malloc (sizeof *cons_block,
+cons_block = NULL;
-						  MEM_TYPE_CONS);
+cons_block_index = CONS_BLOCK_SIZE; /* Force alloc of new cons_block.  */
-cons_block->next = 0;
-bzero ((char *) cons_block->conses, sizeof cons_block->conses);
-cons_block_index = 0;
 cons_free_list = 0;
-n_cons_blocks = 1;
+n_cons_blocks = 0;
 }
 /* Explicitly free a cons cell by putting it on the free-list.  */
 else
 {
 if (cons_block_index == CONS_BLOCK_SIZE)
 	{
 	  register struct cons_block *new;
-	  new = (struct cons_block *) lisp_malloc (sizeof *new,
+	  new = (struct cons_block *) lisp_align_malloc (sizeof *new,
-						   MEM_TYPE_CONS);
+							 MEM_TYPE_CONS);
 	  new->next = cons_block;
 	  cons_block = new;
 	  cons_block_index = 0;
 	  n_cons_blocks++;
 	}
 XSETCONS (val, &cons_block->conses[cons_block_index++]);
 }
 XSETCAR (val, car);
 XSETCDR (val, cdr);
+CONS_UNMARK (XCONS (val));
 consing_since_gc += sizeof (struct Lisp_Cons);
 cons_cells_consed++;
 return val;
 }
 /* P must point to the start of a Lisp_Cons, not be
 	 one of the unused cells in the current cons block,
 	 and not be on the free-list.  */
 return (offset >= 0
+	      && offset < (CONS_BLOCK_SIZE * sizeof b->conses[0])
 	      && offset % sizeof b->conses[0] == 0
 	      && (b != cons_block
 		  || offset / sizeof b->conses[0] < cons_block_index)
 	      && !EQ (((struct Lisp_Cons *) p)->car, Vdead));
 }
 	  mark_p = (live_string_p (m, po)
 		    && !STRING_MARKED_P ((struct Lisp_String *) po));
 	  break;
 	case Lisp_Cons:
-	  mark_p = (live_cons_p (m, po)
+	  mark_p = (live_cons_p (m, po) && !CONS_MARKED_P (XCONS (obj)));
-		    && !XMARKBIT (XCONS (obj)->car));
 	  break;
 	case Lisp_Symbol:
 	  mark_p = (live_symbol_p (m, po) && !XSYMBOL (obj)->gcmarkbit);
 	  break;
 	  if (live_buffer_p (m, p) && !VECTOR_MARKED_P((struct buffer *)p))
 	    XSETVECTOR (obj, p);
 	  break;
 	case MEM_TYPE_CONS:
-	  if (live_cons_p (m, p)
+	  if (live_cons_p (m, p) && !CONS_MARKED_P ((struct Lisp_Cons *) p))
-	      && !XMARKBIT (((struct Lisp_Cons *) p)->car))
 	    XSETCONS (obj, p);
 	  break;
 	case MEM_TYPE_STRING:
 	  if (live_string_p (m, p)
 register struct gcpro *tail;
 for (tail = gcprolist; tail; tail = tail->next)
 for (i = 0; i < tail->nvars; i++)
 	if (!XMARKBIT (tail->var[i]))
 	  {
-	    /* Explicit casting prevents compiler warning about
-	       discarding the `volatile' qualifier.  */
 	    mark_object (tail->var[i]);
 	    XMARK (tail->var[i]);
 	  }
 }
 #endif
 mark_byte_stack ();
 for (bind = specpdl; bind != specpdl_ptr; bind++)
 {
-/* These casts avoid a warning for discarding `volatile'.  */
 mark_object (bind->symbol);
 mark_object (bind->old_value);
 }
 for (catch = catchlist; catch; catch = catch->next)
 {
 break;
 case Lisp_Cons:
 {
 	register struct Lisp_Cons *ptr = XCONS (obj);
-	if (XMARKBIT (ptr->car)) break;
+	if (CONS_MARKED_P (ptr)) break;
 	CHECK_ALLOCATED_AND_LIVE (live_cons_p);
-	XMARK (ptr->car);
+	CONS_MARK (ptr);
 	/* If the cdr is nil, avoid recursion for the car.  */
 	if (EQ (ptr->cdr, Qnil))
 	  {
 	    obj = ptr->car;
 	    cdr_count = 0;
 while (CONSP (tail))
 	{
 	  register struct Lisp_Cons *ptr = XCONS (tail);
-	  if (XMARKBIT (ptr->car))
+	  if (CONS_MARKED_P (ptr))
 	    break;
-	  XMARK (ptr->car);
+	  CONS_MARK (ptr);
 	  if (GC_CONSP (ptr->car)
-	      && ! XMARKBIT (XCAR (ptr->car))
+	      && !CONS_MARKED_P (XCONS (ptr->car))
 	      && GC_MARKERP (XCAR (ptr->car)))
 	    {
-	      XMARK (XCAR_AS_LVALUE (ptr->car));
+	      CONS_MARK (XCONS (ptr->car));
 	      mark_object (XCDR (ptr->car));
 	    }
 	  else
 	    mark_object (ptr->car);
 case Lisp_Misc:
 survives_p = XMARKER (obj)->gcmarkbit;
 break;
 case Lisp_String:
-{
+survives_p = STRING_MARKED_P (XSTRING (obj));
-	struct Lisp_String *s = XSTRING (obj);
-	survives_p = STRING_MARKED_P (s);
-}
 break;
 case Lisp_Vectorlike:
-if (GC_BUFFERP (obj))
+survives_p = GC_SUBRP (obj) || VECTOR_MARKED_P (XVECTOR (obj));
-	survives_p = VECTOR_MARKED_P (XBUFFER (obj));
-else if (GC_SUBRP (obj))
-	survives_p = 1;
-else
-	survives_p = VECTOR_MARKED_P (XVECTOR (obj));
 break;
 case Lisp_Cons:
-survives_p = XMARKBIT (XCAR (obj));
+survives_p = CONS_MARKED_P (XCONS (obj));
 break;
 case Lisp_Float:
 survives_p = FLOAT_MARKED_P (XFLOAT (obj));
 break;
 for (cblk = cons_block; cblk; cblk = *cprev)
 {
 	register int i;
 	int this_free = 0;
 	for (i = 0; i < lim; i++)
-	  if (!XMARKBIT (cblk->conses[i].car))
+	  if (!CONS_MARKED_P (&cblk->conses[i]))
 	    {
 	      this_free++;
 	      *(struct Lisp_Cons **)&cblk->conses[i].cdr = cons_free_list;
 	      cons_free_list = &cblk->conses[i];
 #if GC_MARK_STACK
 #endif
 	    }
 	  else
 	    {
 	      num_used++;
-	      XUNMARK (cblk->conses[i].car);
+	      CONS_UNMARK (&cblk->conses[i]);
 	    }
 	lim = CONS_BLOCK_SIZE;
 	/* If this block contains only free conses and we have already
 	   seen more than two blocks worth of free conses then deallocate
 	   this block.  */
 	if (this_free == CONS_BLOCK_SIZE && num_free > CONS_BLOCK_SIZE)
 	  {
 	    *cprev = cblk->next;
 	    /* Unhook from the free list.  */
 	    cons_free_list = *(struct Lisp_Cons **) &cblk->conses[0].cdr;
-	    lisp_free (cblk);
+	    lisp_align_free (cblk);
 	    n_cons_blocks--;
 	  }
 	else
 	  {
 	    num_free += this_free;

Mercurial > emacs

comparison src/alloc.c @ 51938:20d4eb1de9b0