Mercurial > hg > xemacs-beta

comparison src/dumper.c @ 3092:141c2920ea48

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[xemacs-hg @ 2005-11-25 01:41:31 by crestani] Incremental Garbage Collector
author crestani
date Fri, 25 Nov 2005 01:42:08 +0000
parents ec5f23ea6d2e
children 503174cac05a
comparison
equal deleted inserted replaced
3091:c22d8984148c 3092:141c2920ea48
684 backtrace[me].position = 0; 684 backtrace[me].position = 0;
685 backtrace[me].offset = 0; 685 backtrace[me].offset = 0;
686 } 686 }
687 687
688 static void pdump_register_object (Lisp_Object obj); 688 static void pdump_register_object (Lisp_Object obj);
689 #ifdef NEW_GC
690 static void pdump_register_object_array (Lisp_Object data,
691 Bytecount size,
692 const struct memory_description *desc,
693 int count);
694 #endif /* NEW_GC */
689 static void pdump_register_block_contents (const void *data, 695 static void pdump_register_block_contents (const void *data,
690 Bytecount size, 696 Bytecount size,
691 const struct memory_description * 697 const struct memory_description *
692 desc, 698 desc,
693 int count); 699 int count);
779 (const Rawbyte *) pobj - (const Rawbyte *) data; 785 (const Rawbyte *) pobj - (const Rawbyte *) data;
780 pdump_register_object (dobj); 786 pdump_register_object (dobj);
781 } 787 }
782 break; 788 break;
783 } 789 }
790 #ifdef NEW_GC
791 case XD_LISP_OBJECT_BLOCK_PTR:
792 {
793 EMACS_INT count = lispdesc_indirect_count (desc1->data1, desc,
794 data);
795 const struct sized_memory_description *sdesc =
796 lispdesc_indirect_description (data, desc1->data2.descr);
797 const Lisp_Object *pobj = (const Lisp_Object *) rdata;
798 if (pobj)
799 pdump_register_object_array
800 (*pobj, sdesc->size, sdesc->description, count);
801 break;
802 }
803 #endif /* NEW_GC */
784 case XD_BLOCK_PTR: 804 case XD_BLOCK_PTR:
785 { 805 {
786 EMACS_INT count = lispdesc_indirect_count (desc1->data1, desc, 806 EMACS_INT count = lispdesc_indirect_count (desc1->data1, desc,
787 data); 807 data);
788 const struct sized_memory_description *sdesc = 808 const struct sized_memory_description *sdesc =
874 stderr_out ("Undumpable object type : %s\n", imp->name); 894 stderr_out ("Undumpable object type : %s\n", imp->name);
875 pdump_backtrace (); 895 pdump_backtrace ();
876 } 896 }
877 } 897 }
878 898
899 #ifdef NEW_GC
900 static void
901 pdump_register_object_array (Lisp_Object obj,
902 Bytecount size,
903 const struct memory_description *desc,
904 int count)
905 {
906 struct lrecord_header *objh;
907 const struct lrecord_implementation *imp;
908
909 if (!POINTER_TYPE_P (XTYPE (obj)))
910 return;
911
912 objh = XRECORD_LHEADER (obj);
913 if (!objh)
914 return;
915
916 if (pdump_get_block (objh))
917 return;
918
919 imp = LHEADER_IMPLEMENTATION (objh);
920
921 if (imp->description
922 && RECORD_DUMPABLE (objh))
923 {
924 pdump_bump_depth ();
925 backtrace[pdump_depth - 1].obj = objh;
926 pdump_add_block (pdump_object_table + objh->type,
927 objh, lispdesc_block_size_1 (objh, size, desc), count);
928 pdump_register_block_contents (objh, size, desc, count);
929 --pdump_depth;
930 }
931 else
932 {
933 pdump_alert_undump_object[objh->type]++;
934 stderr_out ("Undumpable object type : %s\n", imp->name);
935 pdump_backtrace ();
936 }
937 }
938 #endif /* NEW_GC */
939
879 /* Register the referenced objects in the array of COUNT blocks located at 940 /* Register the referenced objects in the array of COUNT blocks located at
880 DATA; each block is described by SIZE and DESC. "Block" here simply 941 DATA; each block is described by SIZE and DESC. "Block" here simply
881 means any block of memory. 942 means any block of memory.
882 943
883 This does not register the block of memory itself; it may, for 944 This does not register the block of memory itself; it may, for
992 EMACS_INT val = lispdesc_indirect_count (desc1->data1, desc, 1053 EMACS_INT val = lispdesc_indirect_count (desc1->data1, desc,
993 orig_data); 1054 orig_data);
994 * (int *) rdata = val; 1055 * (int *) rdata = val;
995 break; 1056 break;
996 } 1057 }
1058 #ifdef NEW_GC
1059 case XD_LISP_OBJECT_BLOCK_PTR:
1060 #endif /* NEW_GC */
997 case XD_OPAQUE_DATA_PTR: 1061 case XD_OPAQUE_DATA_PTR:
998 case XD_ASCII_STRING: 1062 case XD_ASCII_STRING:
999 case XD_BLOCK_PTR: 1063 case XD_BLOCK_PTR:
1000 { 1064 {
1001 void *ptr = * (void **) rdata; 1065 void *ptr = * (void **) rdata;
1171 1235
1172 for (i=0; i<lrecord_type_count; i++) 1236 for (i=0; i<lrecord_type_count; i++)
1173 if (pdump_object_table[i].align == align) 1237 if (pdump_object_table[i].align == align)
1174 for (elt = pdump_object_table[i].first; elt; elt = elt->next) 1238 for (elt = pdump_object_table[i].first; elt; elt = elt->next)
1175 { 1239 {
1240 #ifndef NEW_GC
1176 assert (elt->count == 1); 1241 assert (elt->count == 1);
1242 #endif /* not NEW_GC */
1177 f (elt, lrecord_implementations_table[i]->description); 1243 f (elt, lrecord_implementations_table[i]->description);
1178 } 1244 }
1179 } 1245 }
1180 } 1246 }
1181 1247
1232 case XD_HASHCODE: 1298 case XD_HASHCODE:
1233 case XD_INT: 1299 case XD_INT:
1234 case XD_LONG: 1300 case XD_LONG:
1235 case XD_INT_RESET: 1301 case XD_INT_RESET:
1236 break; 1302 break;
1303 #ifdef NEW_GC
1304 case XD_LISP_OBJECT_BLOCK_PTR:
1305 #endif /* NEW_GC */
1237 case XD_OPAQUE_DATA_PTR: 1306 case XD_OPAQUE_DATA_PTR:
1238 case XD_ASCII_STRING: 1307 case XD_ASCII_STRING:
1239 case XD_BLOCK_PTR: 1308 case XD_BLOCK_PTR:
1240 case XD_LO_LINK: 1309 case XD_LO_LINK:
1241 { 1310 {
1250 1319
1251 assert (desc1->data1 == 0); 1320 assert (desc1->data1 == 0);
1252 1321
1253 if (POINTER_TYPE_P (XTYPE (*pobj)) 1322 if (POINTER_TYPE_P (XTYPE (*pobj))
1254 && ! EQ (*pobj, Qnull_pointer)) 1323 && ! EQ (*pobj, Qnull_pointer))
1255 *pobj = wrap_pointer_1 ((char *) pdump_get_mc_addr 1324 *pobj = wrap_pointer_1 ((Rawbyte *) pdump_get_mc_addr
1256 (XPNTR (*pobj))); 1325 (XPNTR (*pobj)));
1257 break; 1326 break;
1258 } 1327 }
1259 case XD_LISP_OBJECT_ARRAY: 1328 case XD_LISP_OBJECT_ARRAY:
1260 { 1329 {
1266 { 1335 {
1267 Lisp_Object *pobj = (Lisp_Object *) rdata + j; 1336 Lisp_Object *pobj = (Lisp_Object *) rdata + j;
1268 1337
1269 if (POINTER_TYPE_P (XTYPE (*pobj)) 1338 if (POINTER_TYPE_P (XTYPE (*pobj))
1270 && ! EQ (*pobj, Qnull_pointer)) 1339 && ! EQ (*pobj, Qnull_pointer))
1271 *pobj = wrap_pointer_1 ((char *) pdump_get_mc_addr 1340 *pobj = wrap_pointer_1 ((Rawbyte *) pdump_get_mc_addr
1272 (XPNTR (*pobj))); 1341 (XPNTR (*pobj)));
1273 } 1342 }
1274 break; 1343 break;
1275 } 1344 }
1276 case XD_DOC_STRING: 1345 case XD_DOC_STRING:
1685 rt.count = pdump_object_table[i].count; 1754 rt.count = pdump_object_table[i].count;
1686 PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt); 1755 PDUMP_WRITE_ALIGNED (pdump_reloc_table, rt);
1687 while (elt) 1756 while (elt)
1688 { 1757 {
1689 EMACS_INT rdata = pdump_get_block (elt->obj)->save_offset; 1758 EMACS_INT rdata = pdump_get_block (elt->obj)->save_offset;
1759 #ifdef NEW_GC
1760 int j;
1761 for (j=0; j<elt->count; j++)
1762 {
1763 PDUMP_WRITE_ALIGNED (EMACS_INT, rdata);
1764 rdata += elt->size;
1765 }
1766 #else /* not NEW_GC */
1690 PDUMP_WRITE_ALIGNED (EMACS_INT, rdata); 1767 PDUMP_WRITE_ALIGNED (EMACS_INT, rdata);
1768 #endif /* not NEW_GC */
1691 elt = elt->next; 1769 elt = elt->next;
1692 } 1770 }
1693 } 1771 }
1694 1772
1695 rt.desc = 0; 1773 rt.desc = 0;
2134 Rawbyte *p; 2212 Rawbyte *p;
2135 EMACS_INT delta; 2213 EMACS_INT delta;
2136 EMACS_INT count; 2214 EMACS_INT count;
2137 pdump_header *header = (pdump_header *) pdump_start; 2215 pdump_header *header = (pdump_header *) pdump_start;
2138 2216
2217 #ifdef NEW_GC
2218 /* This is a DEFVAR_BOOL and gets dumped, but the actual value was
2219 already determined by vdb_install_signal_handler () in
2220 vdb-mprotect.c, which could be different from the value in the
2221 dump file. So store it here and restore it after loading the dump
2222 file. */
2223 int allow_inc_gc = allow_incremental_gc;
2224 #endif /* NEW_GC */
2139 pdump_end = pdump_start + pdump_length; 2225 pdump_end = pdump_start + pdump_length;
2140 2226
2141 delta = ((EMACS_INT) pdump_start) - header->reloc_address; 2227 delta = ((EMACS_INT) pdump_start) - header->reloc_address;
2142 p = pdump_start + header->stab_offset; 2228 p = pdump_start + header->stab_offset;
2143 2229
2161 if (i == 0) 2247 if (i == 0)
2162 { 2248 {
2163 Bytecount real_size = size * elt_count; 2249 Bytecount real_size = size * elt_count;
2164 if (count == 2) 2250 if (count == 2)
2165 { 2251 {
2166 mc_addr = (Rawbyte *) mc_alloc (real_size); 2252 if (elt_count <= 1)
2253 mc_addr = (Rawbyte *) mc_alloc (real_size);
2254 #ifdef NEW_GC
2255 else
2256 mc_addr = (Rawbyte *) mc_alloc_array (size, elt_count);
2257 #endif /* NEW_GC */
2167 #ifdef ALLOC_TYPE_STATS 2258 #ifdef ALLOC_TYPE_STATS
2168 inc_lrecord_stats (real_size, 2259 inc_lrecord_stats (real_size,
2169 (const struct lrecord_header *) 2260 (const struct lrecord_header *)
2170 ((char *) rdata + delta)); 2261 ((Rawbyte *) rdata + delta));
2171 if (((const struct lrecord_header *)
2172 ((char *) rdata + delta))->type
2173 == lrecord_type_string)
2174 inc_lrecord_string_data_stats
2175 (((Lisp_String *) ((char *) rdata + delta))->size_);
2176 #endif /* ALLOC_TYPE_STATS */ 2262 #endif /* ALLOC_TYPE_STATS */
2177 } 2263 }
2178 else 2264 else
2179 mc_addr = (Rawbyte *) xmalloc_and_zero (real_size); 2265 mc_addr = (Rawbyte *) xmalloc_and_zero (real_size);
2180 } 2266 }
2181 else 2267 else
2182 mc_addr += size; 2268 mc_addr += size;
2183 2269
2184 pdump_put_mc_addr ((void *) rdata, (EMACS_INT) mc_addr); 2270 pdump_put_mc_addr ((void *) rdata, (EMACS_INT) mc_addr);
2185 memcpy (mc_addr, (char *) rdata + delta, size); 2271 memcpy (mc_addr, (Rawbyte *) rdata + delta, size);
2186 } 2272 }
2187 } 2273 }
2188 else if (!(--count)) 2274 else if (!(--count))
2189 break; 2275 break;
2190 } 2276 }
2215 { 2301 {
2216 pdump_reloc_table rt = PDUMP_READ_ALIGNED (p, pdump_reloc_table); 2302 pdump_reloc_table rt = PDUMP_READ_ALIGNED (p, pdump_reloc_table);
2217 p = (Rawbyte *) ALIGN_PTR (p, Rawbyte *); 2303 p = (Rawbyte *) ALIGN_PTR (p, Rawbyte *);
2218 if (rt.desc) 2304 if (rt.desc)
2219 { 2305 {
2220 char **reloc = (char **) p; 2306 Rawbyte **reloc = (Rawbyte **) p;
2221 for (i = 0; i < rt.count; i++) 2307 for (i = 0; i < rt.count; i++)
2222 { 2308 {
2223 reloc[i] = (char *) pdump_get_mc_addr (reloc[i]); 2309 reloc[i] = (Rawbyte *) pdump_get_mc_addr (reloc[i]);
2224 pdump_reloc_one_mc (reloc[i], rt.desc); 2310 pdump_reloc_one_mc (reloc[i], rt.desc);
2225 } 2311 }
2226 p += rt.count * sizeof (char *); 2312 p += rt.count * sizeof (Rawbyte *);
2227 } 2313 }
2228 else if (!(--count)) 2314 else if (!(--count))
2229 break; 2315 break;
2230 } 2316 }
2231 #endif /* MC_ALLOC */ 2317 #endif /* MC_ALLOC */
2317 } 2403 }
2318 2404
2319 #ifdef MC_ALLOC 2405 #ifdef MC_ALLOC
2320 xfree (pdump_mc_hash, mc_addr_elt *); 2406 xfree (pdump_mc_hash, mc_addr_elt *);
2321 #endif /* MC_ALLOC */ 2407 #endif /* MC_ALLOC */
2408
2409 #ifdef NEW_GC
2410 allow_incremental_gc = allow_inc_gc;
2411 #endif /* NEW_GC */
2322 2412
2323 return 1; 2413 return 1;
2324 } 2414 }
2325 2415
2326 #ifdef WIN32_NATIVE 2416 #ifdef WIN32_NATIVE