X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fgc-internal.h;h=1a72b88f220dacf05ca97f275adb49a5240d48b5;hb=3a340441c36832861f53fc16478607ea8ab5cb2e;hp=d0f99bf1e05f97078a922fc2389b37e1ac36fcaa;hpb=3bb2fb5b9ecdeebecaded4ac6e5af0f653be8867;p=sbcl.git diff --git a/src/runtime/gc-internal.h b/src/runtime/gc-internal.h index d0f99bf..1a72b88 100644 --- a/src/runtime/gc-internal.h +++ b/src/runtime/gc-internal.h @@ -16,47 +16,151 @@ #ifndef _GC_INTERNAL_H_ #define _GC_INTERNAL_H_ +#include +#include "thread.h" +#include "interr.h" + +#ifdef LISP_FEATURE_GENCGC +#include "gencgc-internal.h" +#else +#include "cheneygc-internal.h" +#endif + +/* disabling gc assertions made no discernable difference to GC speed, + * last I tried it - dan 2003.12.21 + * + * And it's unsafe to do so while things like gc_assert(0 == + * thread_mutex_lock(&allocation_lock)) exist. - MG 2009-01-13 + */ #if 1 -#define gc_assert(ex) do { \ - if (!(ex)) gc_abort(); \ +# define gc_assert(ex) \ +do { \ + if (!(ex)) gc_abort(); \ +} while (0) +# define gc_assert_verbose(ex, fmt, ...) \ +do { \ + if (!(ex)) { \ + fprintf(stderr, fmt, ## __VA_ARGS__); \ + gc_abort(); \ + } \ } while (0) #else -#define gc_assert(ex) +# define gc_assert(ex) +# define gc_assert_verbose(ex, fmt, ...) #endif -#define gc_abort() lose("GC invariant lost, file \"%s\", line %d", \ - __FILE__, __LINE__) + +#define gc_abort() \ + lose("GC invariant lost, file \"%s\", line %d\n", __FILE__, __LINE__) #define CEILING(x,y) (((x) + ((y) - 1)) & (~((y) - 1))) -#define NWORDS(x,y) (CEILING((x),(y)) / (y)) + +static inline unsigned long +NWORDS(unsigned long x, unsigned long n_bits) +{ + /* A good compiler should be able to constant-fold this whole thing, + even with the conditional. */ + if(n_bits <= N_WORD_BITS) { + unsigned long elements_per_word = N_WORD_BITS/n_bits; + + return CEILING(x, elements_per_word)/elements_per_word; + } + else { + /* FIXME: should have some sort of assertion that N_WORD_BITS + evenly divides n_bits */ + return x * (n_bits/N_WORD_BITS); + } +} /* FIXME: Shouldn't this be defined in sbcl.h? */ -#define FUN_RAW_ADDR_OFFSET (6*sizeof(lispobj) - FUN_POINTER_LOWTAG) + +#if defined(LISP_FEATURE_SPARC) +#define FUN_RAW_ADDR_OFFSET 0 +#else +#define FUN_RAW_ADDR_OFFSET (offsetof(struct simple_fun, code) - FUN_POINTER_LOWTAG) +#endif /* values for the *_alloc_* parameters */ -#define FREE_PAGE 0 -#define BOXED_PAGE 1 -#define UNBOXED_PAGE 2 -#define OPEN_REGION_PAGE 4 +#define FREE_PAGE_FLAG 0 +#define BOXED_PAGE_FLAG 1 +#define UNBOXED_PAGE_FLAG 2 +#define OPEN_REGION_PAGE_FLAG 4 +#define CODE_PAGE_FLAG (BOXED_PAGE_FLAG|UNBOXED_PAGE_FLAG) #define ALLOC_BOXED 0 #define ALLOC_UNBOXED 1 #define ALLOC_QUICK 1 -void *gc_general_alloc(int nbytes,int unboxed_p,int quick_p); +#ifdef LISP_FEATURE_GENCGC +#include "gencgc-alloc-region.h" +void * +gc_alloc_with_region(long nbytes,int page_type_flag, struct alloc_region *my_region, + int quick_p); +static inline void * +gc_general_alloc(long nbytes, int page_type_flag, int quick_p) +{ + struct alloc_region *my_region; + if (UNBOXED_PAGE_FLAG == page_type_flag) { + my_region = &unboxed_region; + } else if (BOXED_PAGE_FLAG & page_type_flag) { + my_region = &boxed_region; + } else { + lose("bad page type flag: %d", page_type_flag); + } + return gc_alloc_with_region(nbytes, page_type_flag, my_region, quick_p); +} +#else +extern void *gc_general_alloc(long nbytes,int page_type_flag,int quick_p); +#endif + +static inline lispobj +gc_general_copy_object(lispobj object, long nwords, int page_type_flag) +{ + lispobj *new; + + gc_assert(is_lisp_pointer(object)); + gc_assert(from_space_p(object)); + gc_assert((nwords & 0x01) == 0); + + /* Allocate space. */ + new = gc_general_alloc(nwords*N_WORD_BYTES, page_type_flag, ALLOC_QUICK); + + /* Copy the object. */ + memcpy(new,native_pointer(object),nwords*N_WORD_BYTES); + + return make_lispobj(new, lowtag_of(object)); +} -extern int (*scavtab[256])(lispobj *where, lispobj object); +extern long (*scavtab[256])(lispobj *where, lispobj object); extern lispobj (*transother[256])(lispobj object); -extern int (*sizetab[256])(lispobj *where); +extern long (*sizetab[256])(lispobj *where); extern struct weak_pointer *weak_pointers; /* in gc-common.c */ +extern struct hash_table *weak_hash_tables; /* in gc-common.c */ extern void scavenge(lispobj *start, long n_words); +extern void scavenge_interrupt_contexts(struct thread *thread); +extern void scav_weak_hash_tables(void); +extern void scan_weak_hash_tables(void); extern void scan_weak_pointers(void); -lispobj copy_large_unboxed_object(lispobj object, int nwords); -lispobj copy_unboxed_object(lispobj object, int nwords); -lispobj copy_large_object(lispobj object, int nwords); -lispobj copy_object(lispobj object, int nwords); +lispobj copy_large_unboxed_object(lispobj object, long nwords); +lispobj copy_unboxed_object(lispobj object, long nwords); +lispobj copy_large_object(lispobj object, long nwords); +lispobj copy_object(lispobj object, long nwords); +lispobj copy_code_object(lispobj object, long nwords); + +lispobj *search_read_only_space(void *pointer); +lispobj *search_static_space(void *pointer); +lispobj *search_dynamic_space(void *pointer); + +lispobj *gc_search_space(lispobj *start, size_t words, lispobj *pointer); + +extern int looks_like_valid_lisp_pointer_p(lispobj pointer, lispobj *start_addr); + +extern void scavenge_control_stack(struct thread *th); +extern void scrub_control_stack(); + +#include "fixnump.h" #ifdef LISP_FEATURE_GENCGC #include "gencgc-internal.h" @@ -64,4 +168,10 @@ lispobj copy_object(lispobj object, int nwords); #include "cheneygc-internal.h" #endif +#if N_WORD_BITS == 32 +# define SIMPLE_ARRAY_WORD_WIDETAG SIMPLE_ARRAY_UNSIGNED_BYTE_32_WIDETAG +#elif N_WORD_BITS == 64 +# define SIMPLE_ARRAY_WORD_WIDETAG SIMPLE_ARRAY_UNSIGNED_BYTE_64_WIDETAG +#endif + #endif /* _GC_INTERNAL_H_ */