xemacs-beta: src/dumper.c comparison

comparison src/dumper.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	503174cac05a
children	a4917b3c97cc

comparison

equal deleted inserted replaced

-:79d41cfd8e6b
+:d674024a8674
 int count;
 } pdump_reloc_table;
 static Rawbyte *pdump_rt_list = 0;
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 void
 pdump_objects_unmark (void)
 {
 int i;
 Rawbyte *p = pdump_rt_list;
 	      }
 	  } else
 	    break;
 }
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 /* The structure of the dump file looks like this:
 0		- header
 		- dumped objects
 stab_offset	- mc allocation table (count, size, address) for individual
 		  allocation and  relocation at load time.
 		- nb_root_blocks*struct(void *, size, info) for global
 		  objects to restore
 		- root lisp object address/value couples with the count
 		  preceding the list
 */
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 /* The structure of the dump file looks like this:
 0		- header
 		- dumped objects
 stab_offset	- nb_cv_data*struct(dest, adr) for in-object externally
 		  represented data
 		  data-segment blocks to restore
 		- relocation table
 		- root lisp object address/value couples with the count
 		  preceding the list
 */
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 #define PDUMP_SIGNATURE "XEmacsDP"
 #define PDUMP_SIGNATURE_LEN (sizeof (PDUMP_SIGNATURE) - 1)
 static Bytecount max_size;
 static int pdump_fd;
 static void *pdump_buf;
 static FILE *pdump_out;
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 /* PDUMP_HASHSIZE is a large prime. */
 #define PDUMP_HASHSIZE        1000003
 /* Nothing special about PDUMP_HASH_MULTIPLIER: arbitrary odd integer
 smaller than PDUMP_HASHSIZE. */
 #define PDUMP_HASH_MULTIPLIER   12347
 /* Nothing special about PDUMP_HASH_STEP: arbitrary integer for linear
 probing. */
 #define PDUMP_HASH_STEP        574853
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 #define PDUMP_HASHSIZE 200001
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 static pdump_block_list_elt **pdump_hash;
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 /* Since most pointers are eight bytes aligned, the >>3 allows for a better hash */
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 static int
 pdump_make_hash (const void *obj)
 {
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 return ((unsigned long)(obj) * PDUMP_HASH_MULTIPLIER) % PDUMP_HASHSIZE;
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 return ((unsigned long)(obj)>>3) % PDUMP_HASHSIZE;
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
 /* Return the entry for an already-registered memory block at OBJ,
 or NULL if none. */
 if (align < list->align)
 list->align = align;
 }
 }
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 typedef struct mc_addr_elt
 {
 const void *obj;
 EMACS_INT addr;
 } mc_addr_elt;
 }
 pdump_mc_hash[pos].obj = obj;
 pdump_mc_hash[pos].addr = addr;
 }
-#endif /* MC_ALLOC */
+#endif /* NEW_GC */
 static pdump_block_list *
 pdump_get_block_list (const struct memory_description *desc)
 {
 int i;
 return;
 imp = LHEADER_IMPLEMENTATION (objh);
 if (imp->description
+#ifdef NEW_GC
+/* Objects with finalizers cannot be dumped with the new
+	 allocator's asynchronous finalization strategy. */
+&& !imp->finalizer
+#endif /* not NEW_GC */
 && RECORD_DUMPABLE (objh))
 {
 pdump_bump_depth ();
 backtrace[pdump_depth - 1].obj = objh;
 pdump_add_block (pdump_object_table + objh->type,
 pdump_store_new_pointer_offsets (count, pdump_buf, elt->obj, desc, size);
 }
 retry_fwrite (desc ? pdump_buf : elt->obj, size, count, pdump_out);
 }
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 /* To be able to relocate during load time, more information about the
 dumped objects are needed: The count (for array-like data
 structures), the size of the object, and the location in the dumped
 data.
 */
 for (i=0; i<lrecord_type_count; i++)
 	if (pdump_object_table[i].align == align)
 	  for (elt = pdump_object_table[i].first; elt; elt = elt->next)
 	    {
-#ifndef NEW_GC
-	      assert (elt->count == 1);
-#endif /* not NEW_GC */
 	      f (elt, lrecord_implementations_table[i]->description);
 	    }
 }
 }
 	case XD_HASHCODE:
 	case XD_INT:
 	case XD_LONG:
 	case XD_INT_RESET:
 	  break;
-#ifdef NEW_GC
 	case XD_LISP_OBJECT_BLOCK_PTR:
-#endif /* NEW_GC */
 	case XD_OPAQUE_DATA_PTR:
 	case XD_ASCII_STRING:
 	case XD_BLOCK_PTR:
 	case XD_LO_LINK:
 	  {
 	default:
 	  pdump_unsupported_dump_type (desc1->type, 0);
 	}
 }
 }
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 /* Relocate a single memory block at DATA, described by DESC, from its
 assumed load location to its actual one by adding DELTA to all pointers
 in the block.  Does not recursively relocate any other memory blocks
 pointed to. (We already have a list of all memory blocks in the dump
 file.)  This is used once the dump data has been loaded back in, both
 	default:
 	  pdump_unsupported_dump_type (desc1->type, 0);
 	}
 }
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 static void
 pdump_allocate_offset (pdump_block_list_elt *elt,
 		       const struct memory_description *UNUSED (desc))
 {
 	elt->fcts->convert_free(elt->object, elt->data, elt->size);
 }
 fseek (pdump_out, header.stab_offset, SEEK_SET);
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 {
 EMACS_INT zero = 0;
 pdump_scan_lisp_objects_by_alignment (pdump_dump_mc_data);
 PDUMP_WRITE_ALIGNED (EMACS_INT, zero);
 pdump_scan_non_lisp_objects_by_alignment (pdump_dump_mc_data);
 PDUMP_WRITE_ALIGNED (EMACS_INT, zero);
 }
-#endif /* MC_ALLOC */
+#endif /* NEW_GC */
 pdump_dump_cv_data_info ();
 pdump_dump_cv_ptr_info ();
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 pdump_dump_rtables ();
-#endif /* MC_ALLOC */
+#endif /* NEW_GC */
 pdump_dump_root_block_ptrs ();
 pdump_dump_root_blocks ();
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 pdump_dump_rtables ();
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 pdump_dump_root_lisp_objects ();
 retry_fclose (pdump_out);
 retry_close (pdump_fd);
 pdump_end = pdump_start + pdump_length;
 delta = ((EMACS_INT) pdump_start) - header->reloc_address;
 p = pdump_start + header->stab_offset;
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 pdump_mc_hash = xnew_array_and_zero (mc_addr_elt, PDUMP_HASHSIZE);
 /* Allocate space for each object individually. First the
 Lisp_Objects, then the blocks. */
 count = 2;
 		  Bytecount real_size = size * elt_count;
 		  if (count == 2)
 		    {
 		      if (elt_count <= 1)
 			mc_addr = (Rawbyte *) mc_alloc (real_size);
-#ifdef NEW_GC
 		      else
 			mc_addr = (Rawbyte *) mc_alloc_array (size, elt_count);
-#endif /* NEW_GC */
 #ifdef ALLOC_TYPE_STATS
 		      inc_lrecord_stats (real_size,
 					 (const struct lrecord_header *)
 					 ((Rawbyte *) rdata + delta));
 #endif /* ALLOC_TYPE_STATS */
 	    }
 	}
 else if (!(--count))
 	break;
 }
-#endif /* MC_ALLOC */
+#endif /* NEW_GC */
 /* Get the cv_data array */
 p = (Rawbyte *) ALIGN_PTR (p, pdump_cv_data_dump_info);
 pdump_loaded_cv_data = (pdump_cv_data_dump_info *)p;
 p += header->nb_cv_data*sizeof(pdump_cv_data_dump_info);
 pdump_loaded_cv_ptr[i].save_offset = info.save_offset;
 pdump_loaded_cv_ptr[i].size        = info.size;
 pdump_loaded_cv_ptr[i].adr         = 0;
 }
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 /* Relocate the heap objects */
 pdump_rt_list = p;
 count = 2;
 for (;;)
 {
 	  p += rt.count * sizeof (Rawbyte *);
 	}
 else if (!(--count))
 	  break;
 }
-#endif /* MC_ALLOC */
+#endif /* NEW_GC */
 /* Put back the pdump_root_block_ptrs */
 p = (Rawbyte *) ALIGN_PTR (p, pdump_static_pointer);
 for (i = 0; i < header->nb_root_block_ptrs; i++)
 {
 pdump_static_pointer ptr = PDUMP_READ (p, pdump_static_pointer);
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 (* ptr.address) = (Rawbyte *) pdump_get_mc_addr (ptr.value);
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 (* ptr.address) = ptr.value + delta;
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 }
 /* Put back the pdump_root_blocks and relocate */
 for (i = 0; i < header->nb_root_blocks; i++)
 {
 pdump_root_block info = PDUMP_READ_ALIGNED (p, pdump_root_block);
 memcpy ((void *) info.blockaddr, p, info.size);
 if (info.desc)
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 	pdump_reloc_one_mc ((void *) info.blockaddr, info.desc);
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 	pdump_reloc_one ((void *) info.blockaddr, delta, info.desc);
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 p += info.size;
 }
-#ifndef MC_ALLOC
+#ifndef NEW_GC
 /* Relocate the heap objects */
 pdump_rt_list = p;
 count = 2;
 for (;;)
 {
 	  p += rt.count * sizeof (Rawbyte *);
 	}
 else if (!(--count))
 	  break;
 }
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 /* Put the pdump_root_lisp_objects variables in place */
 i = PDUMP_READ_ALIGNED (p, Elemcount);
 p = (Rawbyte *) ALIGN_PTR (p, pdump_static_Lisp_Object);
 while (i--)
 {
 pdump_static_Lisp_Object obj = PDUMP_READ (p, pdump_static_Lisp_Object);
 if (POINTER_TYPE_P (XTYPE (obj.value)))
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 	obj.value = wrap_pointer_1 ((Rawbyte *) pdump_get_mc_addr
 				    (XPNTR (obj.value)));
-#else /* not MC_ALLOC */
+#else /* not NEW_GC */
 obj.value = wrap_pointer_1 ((Rawbyte *) XPNTR (obj.value) + delta);
-#endif /* not MC_ALLOC */
+#endif /* not NEW_GC */
 (* obj.address) = obj.value;
 }
 /* Final cleanups */
 	}
 else
 	p += sizeof (Lisp_Object) * rt.count;
 }
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 xfree (pdump_mc_hash, mc_addr_elt *);
-#endif /* MC_ALLOC */
+#endif /* NEW_GC */
 #ifdef NEW_GC
 allow_incremental_gc = allow_inc_gc;
 #endif /* NEW_GC */
 if (pdump_file_try (exe_path))
 {
 pdump_load_finish ();
 in_pdump = 0;
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 pdump_free ();
-#endif /* MC_ALLOC */
+#endif /* NEW_GC */
 return 1;
 }
 #ifdef WIN32_NATIVE
 if (pdump_resource_get ())
 {
 if (pdump_load_check ())
 	{
 	  pdump_load_finish ();
 	  in_pdump = 0;
-#ifdef MC_ALLOC
+#ifdef NEW_GC
 	  pdump_free ();
-#endif /* MC_ALLOC */
+#endif /* NEW_GC */
 	  return 1;
 	}
 pdump_free ();
 }

Mercurial > hg > xemacs-beta

comparison src/dumper.c @ 3263:d674024a8674