X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fsgen%2Fsgen-gc.h;h=4c7377e31ee6328a32ce895a6115454ee4cbfcda;hb=a984f20e232d863a9d3b7848023f78816aa282e7;hp=a89a5471dd729c563d09721fcd4a5bd9ccdadf68;hpb=8b671a8c31368e2046aa9546c46f01b99c5c8008;p=mono.git diff --git a/mono/sgen/sgen-gc.h b/mono/sgen/sgen-gc.h index a89a5471dd7..4c7377e31ee 100644 --- a/mono/sgen/sgen-gc.h +++ b/mono/sgen/sgen-gc.h @@ -1,5 +1,6 @@ -/* - * sgen-gc.c: Simple generational GC. +/** + * \file + * Simple generational GC. * * Copyright 2001-2003 Ximian, Inc * Copyright 2003-2010 Novell, Inc. @@ -30,10 +31,12 @@ typedef struct _SgenThreadInfo SgenThreadInfo; #include "mono/utils/atomic.h" #include "mono/utils/mono-os-mutex.h" #include "mono/utils/mono-coop-mutex.h" +#include "mono/utils/ward.h" #include "mono/sgen/sgen-conf.h" #include "mono/sgen/sgen-hash-table.h" #include "mono/sgen/sgen-protocol.h" #include "mono/sgen/gc-internal-agnostic.h" +#include "mono/sgen/sgen-thread-pool.h" /* The method used to clear the nursery */ /* Clearing at nursery collections is the safest, but has bad interactions with caches. @@ -58,9 +61,6 @@ NurseryClearPolicy sgen_get_nursery_clear_policy (void); typedef struct _GCMemSection GCMemSection; struct _GCMemSection { char *data; - mword size; - /* pointer where more data could be allocated if it fits */ - char *next_data; char *end_data; /* * scan starts is an array of pointers to objects equally spaced in the allocation area @@ -116,7 +116,7 @@ extern guint64 stat_objects_copied_major; g_error (__VA_ARGS__); \ } } while (0) -#ifndef HOST_WIN32 +#ifdef HAVE_LOCALTIME_R # define LOG_TIMESTAMP \ do { \ time_t t; \ @@ -184,29 +184,17 @@ sgen_aligned_addr_hash (gconstpointer ptr) #define SGEN_PTR_IN_NURSERY(p,bits,start,end) (((mword)(p) & ~(((mword)1 << (bits)) - 1)) == (mword)(start)) -#ifdef USER_CONFIG - -/* good sizes are 512KB-1MB: larger ones increase a lot memzeroing time */ -#define DEFAULT_NURSERY_SIZE (sgen_nursery_size) extern size_t sgen_nursery_size; -/* The number of trailing 0 bits in DEFAULT_NURSERY_SIZE */ -#define DEFAULT_NURSERY_BITS (sgen_nursery_bits) +extern size_t sgen_nursery_max_size; extern int sgen_nursery_bits; -#else - -#define DEFAULT_NURSERY_SIZE (4*1024*1024) -#define DEFAULT_NURSERY_BITS 22 - -#endif - extern char *sgen_nursery_start; extern char *sgen_nursery_end; static inline MONO_ALWAYS_INLINE gboolean sgen_ptr_in_nursery (void *p) { - return SGEN_PTR_IN_NURSERY ((p), DEFAULT_NURSERY_BITS, sgen_nursery_start, sgen_nursery_end); + return SGEN_PTR_IN_NURSERY ((p), sgen_nursery_bits, sgen_nursery_start, sgen_nursery_end); } static inline MONO_ALWAYS_INLINE char* @@ -305,7 +293,8 @@ enum { SGEN_GC_BIT_FINALIZER_AWARE = 4, }; -void sgen_gc_init (void); +void sgen_gc_init (void) + MONO_PERMIT (need (sgen_lock_gc)); void sgen_os_init (void); @@ -405,8 +394,10 @@ enum { extern SgenHashTable roots_hash [ROOT_TYPE_NUM]; -int sgen_register_root (char *start, size_t size, SgenDescriptor descr, int root_type, int source, const char *msg); -void sgen_deregister_root (char* addr); +int sgen_register_root (char *start, size_t size, SgenDescriptor descr, int root_type, int source, const char *msg) + MONO_PERMIT (need (sgen_lock_gc)); +void sgen_deregister_root (char* addr) + MONO_PERMIT (need (sgen_lock_gc)); typedef void (*IterateObjectCallbackFunc) (GCObject*, size_t, void*); @@ -493,7 +484,6 @@ typedef struct { void sgen_fragment_allocator_add (SgenFragmentAllocator *allocator, char *start, char *end); void sgen_fragment_allocator_release (SgenFragmentAllocator *allocator); -void* sgen_fragment_allocator_serial_alloc (SgenFragmentAllocator *allocator, size_t size); void* sgen_fragment_allocator_par_alloc (SgenFragmentAllocator *allocator, size_t size); void* sgen_fragment_allocator_serial_range_alloc (SgenFragmentAllocator *allocator, size_t desired_size, size_t minimum_size, size_t *out_alloc_size); void* sgen_fragment_allocator_par_range_alloc (SgenFragmentAllocator *allocator, size_t desired_size, size_t minimum_size, size_t *out_alloc_size); @@ -558,11 +548,15 @@ sgen_nursery_is_object_alive (GCObject *obj) typedef struct { gboolean is_split; + gboolean is_parallel; GCObject* (*alloc_for_promotion) (GCVTable vtable, GCObject *obj, size_t objsize, gboolean has_references); + GCObject* (*alloc_for_promotion_par) (GCVTable vtable, GCObject *obj, size_t objsize, gboolean has_references); SgenObjectOperations serial_ops; SgenObjectOperations serial_ops_with_concurrent_major; + SgenObjectOperations parallel_ops; + SgenObjectOperations parallel_ops_with_concurrent_major; void (*prepare_to_space) (char *to_space_bitmap, size_t space_bitmap_size); void (*clear_fragments) (void); @@ -577,7 +571,7 @@ typedef struct { extern SgenMinorCollector sgen_minor_collector; -void sgen_simple_nursery_init (SgenMinorCollector *collector); +void sgen_simple_nursery_init (SgenMinorCollector *collector, gboolean parallel); void sgen_split_nursery_init (SgenMinorCollector *collector); /* Updating references */ @@ -590,7 +584,7 @@ sgen_update_reference (GCObject **p, GCObject *o, gboolean allow_null) { if (!allow_null) SGEN_ASSERT (0, o, "Cannot update a reference with a NULL pointer"); - SGEN_ASSERT (0, !sgen_thread_pool_is_thread_pool_thread (mono_native_thread_id_get ()), "Can't update a reference in the worker thread"); + SGEN_ASSERT (0, !sgen_workers_is_worker_thread (mono_native_thread_id_get ()), "Can't update a reference in the worker thread"); *p = o; } @@ -633,11 +627,10 @@ struct _SgenMajorCollector { size_t section_size; gboolean is_concurrent; gboolean is_parallel; - gboolean needs_thread_pool; gboolean supports_cardtable; gboolean sweeps_lazily; - void* (*alloc_heap) (mword nursery_size, mword nursery_align, int nursery_bits); + void* (*alloc_heap) (mword nursery_size, mword nursery_align); gboolean (*is_object_live) (GCObject *obj); GCObject* (*alloc_small_pinned_obj) (GCVTable vtable, size_t size, gboolean has_references); GCObject* (*alloc_degraded) (GCVTable vtable, size_t size); @@ -661,7 +654,7 @@ struct _SgenMajorCollector { void (*free_non_pinned_object) (GCObject *obj, size_t size); void (*pin_objects) (SgenGrayQueue *queue); void (*pin_major_object) (GCObject *obj, SgenGrayQueue *queue); - void (*scan_card_table) (CardTableScanType scan_type, ScanCopyContext ctx, int job_index, int job_split_count); + void (*scan_card_table) (CardTableScanType scan_type, ScanCopyContext ctx, int job_index, int job_split_count, int block_count); void (*iterate_live_block_ranges) (sgen_cardtable_block_callback callback); void (*iterate_block_ranges) (sgen_cardtable_block_callback callback); void (*update_cardtable_mod_union) (void); @@ -690,8 +683,7 @@ struct _SgenMajorCollector { guint8* (*get_cardtable_mod_union_for_reference) (char *object); long long (*get_and_reset_num_major_objects_marked) (void); void (*count_cards) (long long *num_total_cards, long long *num_marked_cards); - - void (*worker_init_cb) (gpointer worker); + void (*init_block_free_lists) (gpointer *list_p); }; extern SgenMajorCollector major_collector; @@ -700,6 +692,7 @@ void sgen_marksweep_init (SgenMajorCollector *collector); void sgen_marksweep_conc_init (SgenMajorCollector *collector); void sgen_marksweep_conc_par_init (SgenMajorCollector *collector); SgenMajorCollector* sgen_get_major_collector (void); +SgenMinorCollector* sgen_get_minor_collector (void); typedef struct _SgenRememberedSet { @@ -709,12 +702,12 @@ typedef struct _SgenRememberedSet { void (*wbarrier_object_copy) (GCObject* obj, GCObject *src); void (*wbarrier_generic_nostore) (gpointer ptr); void (*record_pointer) (gpointer ptr); + void (*wbarrier_range_copy) (gpointer dest, gpointer src, int count); - void (*scan_remsets) (ScanCopyContext ctx); + void (*start_scan_remsets) (void); void (*clear_cards) (void); - void (*finish_minor_collection) (void); gboolean (*find_address) (char *addr); gboolean (*find_address_with_cards) (char *cards_start, guint8 *cards, char *addr); } SgenRememberedSet; @@ -730,7 +723,7 @@ void mono_gc_wbarrier_generic_nostore (gpointer ptr); void mono_gc_wbarrier_generic_store (gpointer ptr, GCObject* value); void mono_gc_wbarrier_generic_store_atomic (gpointer ptr, GCObject *value); -void sgen_wbarrier_value_copy_bitmap (gpointer _dest, gpointer _src, int size, unsigned bitmap); +void sgen_wbarrier_range_copy (gpointer _dest, gpointer _src, int size); static inline SgenDescriptor sgen_obj_get_descriptor (GCObject *obj) @@ -808,27 +801,35 @@ void sgen_clear_togglerefs (char *start, char *end, ScanCopyContext ctx); void sgen_process_togglerefs (void); void sgen_register_test_toggleref_callback (void); -void sgen_mark_bridge_object (GCObject *obj); -void sgen_collect_bridge_objects (int generation, ScanCopyContext ctx); +void sgen_mark_bridge_object (GCObject *obj) + MONO_PERMIT (need (sgen_gc_locked)); +void sgen_collect_bridge_objects (int generation, ScanCopyContext ctx) + MONO_PERMIT (need (sgen_gc_locked)); typedef gboolean (*SgenObjectPredicateFunc) (GCObject *obj, void *user_data); -void sgen_null_links_if (SgenObjectPredicateFunc predicate, void *data, int generation, gboolean track); +void sgen_null_links_if (SgenObjectPredicateFunc predicate, void *data, int generation, gboolean track) + MONO_PERMIT (need (sgen_gc_locked, sgen_world_stopped)); gboolean sgen_gc_is_object_ready_for_finalization (GCObject *object); -void sgen_gc_lock (void); -void sgen_gc_unlock (void); +void sgen_gc_lock (void) MONO_PERMIT (use (sgen_lock_gc), grant (sgen_gc_locked), revoke (sgen_lock_gc)); +void sgen_gc_unlock (void) MONO_PERMIT (use (sgen_gc_locked), revoke (sgen_gc_locked), grant (sgen_lock_gc)); void sgen_queue_finalization_entry (GCObject *obj); const char* sgen_generation_name (int generation); -void sgen_finalize_in_range (int generation, ScanCopyContext ctx); -void sgen_null_link_in_range (int generation, ScanCopyContext ctx, gboolean track); -void sgen_process_fin_stage_entries (void); +void sgen_finalize_in_range (int generation, ScanCopyContext ctx) + MONO_PERMIT (need (sgen_gc_locked)); +void sgen_null_link_in_range (int generation, ScanCopyContext ctx, gboolean track) + MONO_PERMIT (need (sgen_gc_locked, sgen_world_stopped)); +void sgen_process_fin_stage_entries (void) + MONO_PERMIT (need (sgen_gc_locked)); gboolean sgen_have_pending_finalizers (void); -void sgen_object_register_for_finalization (GCObject *obj, void *user_data); +void sgen_object_register_for_finalization (GCObject *obj, void *user_data) + MONO_PERMIT (need (sgen_lock_gc)); -void sgen_finalize_if (SgenObjectPredicateFunc predicate, void *user_data); +void sgen_finalize_if (SgenObjectPredicateFunc predicate, void *user_data) + MONO_PERMIT (need (sgen_lock_gc)); void sgen_remove_finalizers_if (SgenObjectPredicateFunc predicate, void *user_data, int generation); void sgen_set_suspend_finalizers (void); @@ -850,19 +851,25 @@ enum { void sgen_pin_object (GCObject *object, SgenGrayQueue *queue); void sgen_set_pinned_from_failed_allocation (mword objsize); -void sgen_ensure_free_space (size_t size, int generation); -void sgen_gc_collect (int generation); -void sgen_perform_collection (size_t requested_size, int generation_to_collect, const char *reason, gboolean wait_to_finish, gboolean stw); +void sgen_ensure_free_space (size_t size, int generation) + MONO_PERMIT (need (sgen_gc_locked, sgen_stop_world)); +void sgen_gc_collect (int generation) + MONO_PERMIT (need (sgen_lock_gc, sgen_stop_world)); +void sgen_perform_collection (size_t requested_size, int generation_to_collect, const char *reason, gboolean wait_to_finish, gboolean stw) + MONO_PERMIT (need (sgen_gc_locked, sgen_stop_world)); int sgen_gc_collection_count (int generation); /* FIXME: what exactly does this return? */ -size_t sgen_gc_get_used_size (void); +size_t sgen_gc_get_used_size (void) + MONO_PERMIT (need (sgen_lock_gc)); size_t sgen_gc_get_total_heap_allocation (void); /* STW */ -void sgen_stop_world (int generation); -void sgen_restart_world (int generation); +void sgen_stop_world (int generation) + MONO_PERMIT (need (sgen_gc_locked), use (sgen_stop_world), grant (sgen_world_stopped), revoke (sgen_stop_world)); +void sgen_restart_world (int generation) + MONO_PERMIT (need (sgen_gc_locked), use (sgen_world_stopped), revoke (sgen_world_stopped), grant (sgen_stop_world)); gboolean sgen_is_world_stopped (void); gboolean sgen_set_allow_synchronous_major (gboolean flag); @@ -885,7 +892,8 @@ extern mword los_memory_usage; extern mword los_memory_usage_total; void sgen_los_free_object (LOSObject *obj); -void* sgen_los_alloc_large_inner (GCVTable vtable, size_t size); +void* sgen_los_alloc_large_inner (GCVTable vtable, size_t size) + MONO_PERMIT (need (sgen_gc_locked, sgen_stop_world)); void sgen_los_sweep (void); gboolean sgen_ptr_is_in_los (char *ptr, char **start); void sgen_los_iterate_objects (IterateObjectCallbackFunc cb, void *user_data); @@ -907,12 +915,12 @@ void sgen_los_mark_mod_union_card (GCObject *mono_obj, void **ptr); void sgen_clear_nursery_fragments (void); void sgen_nursery_allocator_prepare_for_pinning (void); -void sgen_nursery_allocator_set_nursery_bounds (char *nursery_start, char *nursery_end); +void sgen_nursery_allocator_set_nursery_bounds (char *nursery_start, size_t min_size, size_t max_size); +void sgen_resize_nursery (gboolean need_shrink); mword sgen_build_nursery_fragments (GCMemSection *nursery_section, SgenGrayQueue *unpin_queue); void sgen_init_nursery_allocator (void); void sgen_nursery_allocator_init_heavy_stats (void); void sgen_init_allocator (void); -char* sgen_nursery_alloc_get_upper_alloc_bound (void); void* sgen_nursery_alloc (size_t size); void* sgen_nursery_alloc_range (size_t size, size_t min_size, size_t *out_alloc_size); gboolean sgen_can_alloc_size (size_t size); @@ -923,13 +931,14 @@ void sgen_nursery_alloc_prepare_for_major (void); GCObject* sgen_alloc_for_promotion (GCObject *obj, size_t objsize, gboolean has_references); -GCObject* sgen_alloc_obj_nolock (GCVTable vtable, size_t size); +GCObject* sgen_alloc_obj_nolock (GCVTable vtable, size_t size) + MONO_PERMIT (need (sgen_gc_locked, sgen_stop_world)); GCObject* sgen_try_alloc_obj_nolock (GCVTable vtable, size_t size); /* Threads */ -void* sgen_thread_register (SgenThreadInfo* info, void *addr); -void sgen_thread_unregister (SgenThreadInfo *p); +void* sgen_thread_attach (SgenThreadInfo* info); +void sgen_thread_detach_with_lock (SgenThreadInfo *p); /* Finalization/ephemeron support */ @@ -969,20 +978,28 @@ sgen_is_object_alive_for_current_gen (GCObject *object) return sgen_major_is_object_alive (object); } -int sgen_gc_invoke_finalizers (void); +int sgen_gc_invoke_finalizers (void) + MONO_PERMIT (need (sgen_lock_gc)); /* GC handles */ void sgen_init_gchandles (void); -void sgen_null_links_if (SgenObjectPredicateFunc predicate, void *data, int generation, gboolean track); +void sgen_null_links_if (SgenObjectPredicateFunc predicate, void *data, int generation, gboolean track) + MONO_PERMIT (need (sgen_gc_locked)); typedef gpointer (*SgenGCHandleIterateCallback) (gpointer hidden, GCHandleType handle_type, int max_generation, gpointer user); -void sgen_gchandle_iterate (GCHandleType handle_type, int max_generation, SgenGCHandleIterateCallback callback, gpointer user); +guint32 sgen_gchandle_new (GCObject *obj, gboolean pinned); +guint32 sgen_gchandle_new_weakref (GCObject *obj, gboolean track_resurrection); +void sgen_gchandle_iterate (GCHandleType handle_type, int max_generation, SgenGCHandleIterateCallback callback, gpointer user) + MONO_PERMIT (need (sgen_world_stopped)); void sgen_gchandle_set_target (guint32 gchandle, GCObject *obj); -void sgen_mark_normal_gc_handles (void *addr, SgenUserMarkFunc mark_func, void *gc_data); +void sgen_mark_normal_gc_handles (void *addr, SgenUserMarkFunc mark_func, void *gc_data) + MONO_PERMIT (need (sgen_world_stopped)); gpointer sgen_gchandle_get_metadata (guint32 gchandle); +GCObject *sgen_gchandle_get_target (guint32 gchandle); +void sgen_gchandle_free (guint32 gchandle); /* Other globals */ @@ -999,6 +1016,7 @@ extern mword total_promoted_size; extern mword total_allocated_major; extern volatile gboolean sgen_suspend_finalizers; extern MonoCoopMutex gc_mutex; +extern volatile gboolean concurrent_collection_in_progress; /* Nursery helpers. */ @@ -1024,9 +1042,12 @@ typedef enum { void sgen_clear_tlabs (void); -GCObject* sgen_alloc_obj (GCVTable vtable, size_t size); -GCObject* sgen_alloc_obj_pinned (GCVTable vtable, size_t size); -GCObject* sgen_alloc_obj_mature (GCVTable vtable, size_t size); +GCObject* sgen_alloc_obj (GCVTable vtable, size_t size) + MONO_PERMIT (need (sgen_lock_gc, sgen_stop_world)); +GCObject* sgen_alloc_obj_pinned (GCVTable vtable, size_t size) + MONO_PERMIT (need (sgen_lock_gc, sgen_stop_world)); +GCObject* sgen_alloc_obj_mature (GCVTable vtable, size_t size) + MONO_PERMIT (need (sgen_lock_gc, sgen_stop_world)); /* Debug support */ @@ -1034,7 +1055,8 @@ void sgen_check_remset_consistency (void); void sgen_check_mod_union_consistency (void); void sgen_check_major_refs (void); void sgen_check_whole_heap (gboolean allow_missing_pinning); -void sgen_check_whole_heap_stw (void); +void sgen_check_whole_heap_stw (void) + MONO_PERMIT (need (sgen_gc_locked, sgen_stop_world)); void sgen_check_objref (char *obj); void sgen_check_heap_marked (gboolean nursery_must_be_pinned); void sgen_check_nursery_objects_pinned (gboolean pinned);