X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fruntime%2Fgencgc-internal.h;h=574b1985569b8fbd490f212f389dcdb36f99b788;hb=7f1e94ae961a198e00daf281eb1dc858e5b2dcc7;hp=9fc3094a47921a1330f767b3b579a5d426a0a967;hpb=e6c3f1d3e416bd473a9e476e6f95235c783794a3;p=sbcl.git diff --git a/src/runtime/gencgc-internal.h b/src/runtime/gencgc-internal.h index 9fc3094..574b198 100644 --- a/src/runtime/gencgc-internal.h +++ b/src/runtime/gencgc-internal.h @@ -19,23 +19,55 @@ #ifndef _GENCGC_INTERNAL_H_ #define _GENCGC_INTERNAL_H_ +#include #include "gc.h" #include "gencgc-alloc-region.h" #include "genesis/code.h" -/* Size of a page, in bytes. FIXME: needs to be conditionalized per - * architecture, preferably by someone with a clue as to what page - * sizes are on archs other than x86 and PPC - Patrik */ -#define PAGE_BYTES 4096 - void gc_free_heap(void); -inline page_index_t find_page_index(void *); -inline void *page_address(page_index_t); +extern page_index_t find_page_index(void *); +extern void *page_address(page_index_t); int gencgc_handle_wp_violation(void *); + +#if GENCGC_CARD_BYTES > USHRT_MAX +# if GENCGC_CARD_BYTES > UINT_MAX +# error "GENCGC_CARD_BYTES unexpectedly large." +# else +# define PAGE_BYTES_FMT "u" + typedef unsigned int page_bytes_t; +# endif +#else +# define PAGE_BYTES_FMT "hu" + typedef unsigned short page_bytes_t; +#endif + +/* Note that this structure is also used from Lisp-side in + * src/code/room.lisp, and the Lisp-side structure layout is currently + * not groveled from C code but hardcoded. Any changes to the + * structure layout need to be also made there. + * + * FIXME: We should probably just define this structure in Lisp, and + * output the C version in genesis. -- JES, 2006-12-30. + */ struct page { + /* This is the offset from the first byte of some object in memory + * prior to and no closer than the start of the page to the start + * of the page. Lower values here are better, 0 is ideal. This + * is useful for determining where to start when scanning forward + * through a heap page (either for conservative root validation or + * for scavenging). + */ + os_vm_size_t scan_start_offset; + + /* the number of bytes of this page that are used. This may be less + * than the actual bytes used for pages within the current + * allocation regions. It should be 0 for all unallocated pages (not + * hard to achieve). + */ + page_bytes_t bytes_used; - unsigned int + unsigned char /* This is set when the page is write-protected. This should * always reflect the actual write_protect status of a page. * (If the page is written into, we catch the exception, make @@ -46,10 +78,17 @@ struct page { * OSes). This is useful for re-scavenging pages that are * written during a GC. */ write_protected_cleared :1, - /* the region the page is allocated to: 0 for a free page; 1 - * for boxed objects; 2 for unboxed objects. If the page is - * free the following slots are invalid (well the bytes_used - * must be 0). */ + /* 000 free + * ?01 boxed data + * ?10 unboxed data + * ?11 code + * 1?? open region + * + * Constants for this field are defined in gc-internal.h, the + * xxx_PAGE_FLAG definitions. + * + * If the page is free the following slots are invalid, except + * for the bytes_used which must be zero. */ allocated :3, /* If this page should not be moved during a GC then this flag * is set. It's only valid during a GC for allocated pages. */ @@ -57,58 +96,51 @@ struct page { /* If the page is part of a large object then this flag is * set. No other objects should be allocated to these pages. * This is only valid when the page is allocated. */ - large_object :1; + large_object :1, + /* Cleared if the page is known to contain only zeroes. */ + need_to_zero :1; /* the generation that this page belongs to. This should be valid * for all pages that may have objects allocated, even current * allocation region pages - this allows the space of an object to * be easily determined. */ generation_index_t gen; - - /* the number of bytes of this page that are used. This may be less - * than the actual bytes used for pages within the current - * allocation regions. It should be 0 for all unallocated pages (not - * hard to achieve). */ - int bytes_used; - - /* The name of this field is not well-chosen for its actual use. - * This is the offset from the start of the page to the start - * of the alloc_region which contains/contained it. It's negative or 0 - */ - long first_object_offset; }; + /* values for the page.allocated field */ -/* the number of pages needed for the dynamic space - rounding up */ -#define NUM_PAGES ((page_index_t) ((DYNAMIC_SPACE_SIZE+PAGE_BYTES-1)/PAGE_BYTES)) - -extern struct page page_table[NUM_PAGES]; +extern page_index_t page_table_pages; +extern struct page *page_table; /* forward declarations */ - -void sniff_code_object(struct code *code, unsigned long displacement); +#ifdef LISP_FEATURE_X86 +void sniff_code_object(struct code *code, os_vm_size_t displacement); void gencgc_apply_code_fixups(struct code *old_code, struct code *new_code); +#endif -long update_dynamic_space_free_pointer(void); -void gc_alloc_update_page_tables(int unboxed, - struct alloc_region *alloc_region); +sword_t update_dynamic_space_free_pointer(void); +void gc_alloc_update_page_tables(int page_type_flag, struct alloc_region *alloc_region); void gc_alloc_update_all_page_tables(void); void gc_set_region_empty(struct alloc_region *region); /* * predicates */ + static inline boolean space_matches_p(lispobj obj, generation_index_t space) { - page_index_t page_index=(void*)obj - (void *)DYNAMIC_SPACE_START; - return ((page_index >= 0) - && ((page_index = - ((unsigned long)page_index)/PAGE_BYTES) < NUM_PAGES) - && (page_table[page_index].gen == space)); + if (obj >= DYNAMIC_SPACE_START) { + page_index_t page_index=((pointer_sized_uint_t)obj + - DYNAMIC_SPACE_START) / GENCGC_CARD_BYTES; + return ((page_index < page_table_pages) && + (page_table[page_index].gen == space)); + } else { + return 0; + } } static inline boolean @@ -124,5 +156,6 @@ new_space_p(lispobj obj) } extern page_index_t last_free_page; +extern boolean gencgc_partial_pickup; #endif