| Commit message (Collapse) | Author | Age | Files | Lines |
|
|
|
|
|
|
|
|
| |
(refactoring)
* pthread_support.c (GC_lookup_thread): Expect break on the first
iteration of the loop.
* win32_threads.c [GC_PTHREADS] (GC_lookup_by_pthread): Expect return
on the first iteration of the first loop.
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* darwin_stop_world.c (GC_push_all_stacks): Add assertion that thread
entry is located in the proper hash table chain (by id).
* pthread_stop_world.c (GC_push_all_stacks): Likewise.
* win32_threads.c (GC_push_all_stacks): Likewise.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Issue #542 (bdwgc).
The scenario of the failure (on Linux):
- Find-leak mode is on
- pthread_create/join primitives are not redirected
- GC is initialized from a thread other than primordial
- that thread is terminated (but not unregistered as the 1st one in GC)
- the primordial thread exits and launches GC_exit_check
- GC_gcollect tries to suspend the terminated thread by sending a signal
- the signal is not delivered but pthread_kill just returns zero
- the signal sending is retried until aborting with the proper message.
The proposed solution (workaround) is not to call GC_gcollect at
the process exit (in the find-leak mode) if GC_init was called from
a thread other than primordial one.
Check in GC_exit_check() (which is called if GC_find_leak) that the
thread executing at-exit functions is the same as the one performed
the GC initialization, otherwise the latter thread might already be
dead but still registered and this, as a consequence, might cause
a signal delivery fail when suspending the threads on platforms that
do not guarantee ESRCH returned if the signal is not delivered (as
observed on Ubuntu 22).
* include/private/gc_priv.h [THREADS && !DONT_USE_ATEXIT]
(GC_is_main_thread): Declare GC_INNER function.
* include/private/pthread_support.h [GC_WIN32_THREADS
&& !DONT_USE_ATEXIT] (GC_main_thread_id): Declare variable.
* include/private/pthread_support.h [GC_WIN32_THREADS
&& !GC_NO_THREADS_DISCOVERY] (GC_main_thread_id): Do not depend on
GC_ASSERTIONS.
* misc.c [!DONT_USE_ATEXIT && THREADS] (GC_exit_check): If not
GC_is_main_thread() or not GC_thread_is_registered() then do not call
GC_gcollect(); add comment; do not set and clear GC_in_thread_creation.
* pthread_support.c [!GC_NO_THREADS_DISCOVERY && GC_WIN32_THREADS
|| !DONT_USE_ATEXIT] (GC_main_thread_id): Define variable.
* pthread_support.c [!DONT_USE_ATEXIT] (GC_is_main_thread): Implement.
* pthread_support.c [!GC_WIN32_THREADS] (GC_thr_init): Define self_id
local variable.
* pthread_support.c [!GC_WIN32_THREADS && !DONT_USE_ATEXIT]
(GC_thr_init): Set GC_main_thread_id.
* win32_threads.c [!DONT_USE_ATEXIT] (GC_thr_init): Likewise.
* win32_threads.c [!GC_NO_THREADS_DISCOVERY] (GC_main_thread_id): Do
not define variable.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* include/private/pthread_support.h (GC_self_thread_inner): New macro.
* pthread_stop_world.c (GC_lookup_thread_async): Replace to no-arg
GC_lookup_self_thread_async(); update comment.
* pthread_stop_world.c (GC_suspend_handler_inner): Remove self local
variable, use pthread_self() instead.
* pthread_stop_world.c [NACL] (__nacl_suspend_thread_if_needed):
Likewise.
* pthread_stop_world.c (GC_suspend_handler_inner): Call
GC_lookup_self_thread_async() instead of GC_lookup_thread_async(self).
* pthread_stop_world.c [NACL] (GC_nacl_shutdown_gc_thread): Do not use
GC_lookup_thread(pthread_self()) in assertion.
* win32_threads.c (GC_thr_init): Likewise.
* pthread_support.c (GC_self_thread): New STATIC function.
* pthread_support.c [!GC_NO_FINALIZATION] (GC_reset_finalizer_nested):
Remove me local variable.
* pthread_support.c [!GC_NO_FINALIZATION] (GC_reset_finalizer_nested,
GC_check_finalizer_nested): Call GC_self_thread_inner() instead of
GC_lookup_thread(thread_id_self()).
* pthread_support.c [!GC_WIN32_THREADS] (GC_register_altstack,
GC_thr_init): Likewise.
* pthread_support.c [THREAD_LOCAL_ALLOC] (GC_init_parallel): Likewise.
* pthread_support.c (GC_do_blocking_inner, GC_set_stackbottom,
GC_get_stackbottom, GC_call_with_gc_active, GC_unregister_my_thread,
GC_register_my_thread): Likewise.
* pthread_support.c [GC_HAVE_PTHREAD_EXIT] (GC_pthread_exit): Likewise.
* pthread_support.c [GC_ASSERTIONS && THREAD_LOCAL_ALLOC]
(GC_is_thread_tsd_valid): Use GC_self_thread() instead of locking and
GC_lookup_thread(thread_id_self()).
* pthread_support.c (GC_thread_is_registered): Likewise.
* pthread_support.c [GC_ASSERTIONS] (GC_allow_register_threads):
Likewise.
* pthread_support.c (GC_thread_is_registered, GC_get_stackbottom,
GC_call_with_gc_active, GC_unregister_my_thread,
GC_register_my_thread): Remove self_id local variable.
* pthread_support.c [!GC_WIN32_THREADS] (GC_register_altstack,
GC_thr_init): Likewise.
* pthread_support.c [GC_HAVE_PTHREAD_EXIT] (GC_pthread_exit): Likewise.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(cherry-pick of c511d4a from Unity-Technologies/bdwgc)
Dynamically lookup IsWow64Process2 and fallback to IsWow64Process if
needed. Store TIB on each thread and lookup via call to NtCurrentTeb
on thread registration rather than calling GetThreadSelectorEntry
which is not available on UWP.
* include/private/pthread_support.h [WOW64_THREAD_CONTEXT_WORKAROUND
&& MSWINRT_FLAVOR] (GC_thread): Add tib field.
* win32_threads.c [WOW64_THREAD_CONTEXT_WORKAROUND && MSWINRT_FLAVOR]
(GC_register_my_thread_inner): Call NtCurrentTeb() and set tib field;
add comment.
* win32_threads.c [WOW64_THREAD_CONTEXT_WORKAROUND] (isWow64): Change
type from BOOL to GC_bool.
* win32_threads.c [WOW64_THREAD_CONTEXT_WORKAROUND]
(GC_push_stack_for): Define SegFs and selector local variables only
unless MSWINRT_FLAVOR; do not call GetThreadSelectorEntry() if
MSWINRT_FLAVOR.
* win32_threads.c [WOW64_THREAD_CONTEXT_WORKAROUND && MSWINRT_FLAVOR]
(GetModuleHandleW): Declare.
* win32_threads.c [WOW64_THREAD_CONTEXT_WORKAROUND] (is_wow64_process):
New static function (move part of code from GC_thr_init).
* win32_threads.c [WOW64_THREAD_CONTEXT_WORKAROUND && MSWINRT_FLAVOR]
(is_wow64_process): Call IsWow64Process2() dynamically; call
IsWow64Process() statically (if the previous one failed).
* win32_threads.c [WOW64_THREAD_CONTEXT_WORKAROUND] (GC_thr_init): Call
is_wow64_process().
Co-authored-by: Ivan Maidanski <ivmai@mail.ru>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* include/private/pthread_support.h [GC_WIN32_THREADS && GC_PTHREADS]
(GC_lookup_by_pthread): Move declaration down.
* include/private/pthread_support.h [GC_PTHREADS && !GC_WIN32_THREADS]
(GC_lookup_by_pthread): Define as macro (to GC_lookup_thread).
* pthread_stop_world.c [!NACL && GC_ENABLE_SUSPEND_THREAD]
(GC_suspend_thread, GC_resume_thread, GC_is_thread_suspended): Use
GC_lookup_by_pthread() instead of GC_lookup_thread().
* pthread_support.c [!GC_NO_PTHREAD_CANCEL && GC_PTHREADS
&& CANCEL_SAFE] (GC_pthread_cancel): Likewise.
* pthread_support.c [GC_PTHREADS && !SN_TARGET_ORBIS
&& !SN_TARGET_PSP2] (GC_pthread_join, GC_pthread_detach): Likewise.
* pthread_support.c [GC_PTHREADS && !SN_TARGET_ORBIS
&& !SN_TARGET_PSP2 && GC_WIN32_THREADS] (GC_pthread_join,
GC_pthread_detach): Wrap GC_lookup_by_pthread() call into LOCK/UNLOCK.
* win32_threads.c [GC_PTHREADS] (GC_lookup_by_pthread): Refine comment;
define id local variable; remove hv_guess local variable;
replace break with return p; remove LOCK() and UNLOCK(); add assertion
that the GC lock is held.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* pthread_support.c (GC_push_thread_structures): Add assertion that
first_thread.tm.next and first_thread.status are null.
* pthread_support.c (GC_new_thread): Rename id argument to self_id;
add assertion that GC_in_thread_creation is off on entrance; set
GC_in_thread_creation before GC_INTERNAL_MALLOC() first call and clear
it after the second one; if crtn or result is null then ABORT instead
of returning NULL.
* pthread_support.c [!GC_DISABLE_INCREMENTAL]
(GC_wait_for_gc_completion): Add assertion that GC_in_thread_creation
is off before it is set.
* pthread_support.c [!GC_WIN32_THREADS] (GC_register_my_thread_inner):
Do not change GC_in_thread_creation value in this function directly;
do not check the result of GC_new_thread().
* win32_threads.c (GC_register_my_thread_inner): Likewise.
* win32_threads.c (GC_register_my_thread_inner): Remove assertion that
the lock is held.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
This commit removes GC_delete_gc_thread_no_free, thus eliminating code
duplication between GC_delete_thread and GC_delete_gc_thread_no_free.
* include/private/pthread_support.h [GC_WIN32_THREADS && !GC_PTHREADS]
(GC_delete_gc_thread_no_free): Rename to GC_delete_thread.
* pthread_support.c [CAN_HANDLE_FORK] (GC_remove_all_threads_but_me):
Add TODO item.
* pthread_support.c (GC_delete_thread): Change argument from
thread_id_t to GC_thread; update comment (copy it from
GC_delete_gc_thread_no_free); change STATIC to GC_INNER_WIN32THREAD;
define id as local variable; iterate over GC_threads[hv] chain until
t is found.
* pthread_support.c [GC_WIN32_THREADS && !MSWINCE] (GC_delete_thread):
Move CloseHandle() call to the beginning of function.
* pthread_support.c [!GC_NO_THREADS_DISCOVERY && GC_WIN32_THREADS]
(GC_delete_thread): Do not call GC_win32_dll_lookup_thread; expand code
of GC_delete_gc_thread_no_free.
* pthread_support.c [!SN_TARGET_ORBIS && !SN_TARGET_PSP2]
(GC_delete_gc_thread_no_free): Remove.
* pthread_support.c [!THREAD_LOCAL_ALLOC]
(GC_unregister_my_thread_inner): Do not cast me to void.
* pthread_support.c (GC_unregister_my_thread_inner): Pass me (instead
of thread_id_self()) to GC_delete_thread().
* pthread_support.c [GC_PTHREADS && !SN_TARGET_ORBIS
&& !SN_TARGET_PSP2] (GC_pthread_join, GC_pthread_detach): Call
GC_delete_thread() instead of GC_delete_gc_thread_no_free(),
GC_INTERNAL_FREE(t->crtn) and GC_INTERNAL_FREE(t).
* pthread_support.c [GC_PTHREADS && !SN_TARGET_ORBIS
&& !SN_TARGET_PSP2] (GC_pthread_detach): Do not set DETACHED in
t->flags if KNOWN_FINISHED(t).
* win32_threads.c [!MSWINCE && !GC_PTHREADS] (GC_suspend): Remove
assertion about GC_win32_dll_threads.
* win32_threads.c [!MSWINCE && !GC_PTHREADS] (GC_suspend): Call
GC_delete_thread() instead of GC_delete_gc_thread_no_free().
* win32_threads.c [!GC_NO_THREADS_DISCOVERY] (GC_DllMain): Likewise.
* win32_threads.c [MSWIN32 && !CONSOLE_LOG || MSWINCE] (GC_stop_world):
Update comment.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
This is to match the behavior on non-Windows platforms (and to match
the comment of GC_delete_thread).
* include/private/pthread_support.h [GC_WIN32_THREADS
&& !GC_NO_THREADS_DISCOVERY && GC_ASSERTIONS] (GC_main_thread_id):
Declare variable.
* include/private/pthread_support.h [GC_WIN32_THREADS
&& !GC_NO_THREADS_DISCOVERY] (GC_delete_thread): Remove.
* pthread_support.c (GC_delete_thread): Change GC_INNER_WIN32THREAD to
STATIC.
* pthread_support.c [!GC_NO_THREADS_DISCOVERY && GC_WIN32_THREADS]
(GC_delete_thread): Call GC_win32_dll_lookup_thread instead of
GC_lookup_thread and do not check its result.
* pthread_support.c [!GC_NO_THREADS_DISCOVERY && GC_WIN32_THREADS]
(GC_unregister_my_thread): Do not call GC_delete_thread (directly) if
GC_win32_dll_threads; add assertion to check that the thread to b
unregistered is main one if GC_win32_dll_threads; add comment.
* win32_threads.c [!GC_NO_THREADS_DISCOVERY] (main_thread_id): Rename
to GC_main_thread_id and change static to GC_INNER to STATIC.
* win32_threads.c (GC_register_my_thread_inner): Update comment to
mention GC_win32_dll_lookup_thread instead of GC_delete_thread.
* win32_threads.c (GC_thr_init): Define self_id local variable and use
it instead of main_thread_id; do not define main_thread_id as macro;
do not undefine main_thread_id.
* win32_threads.c [!GC_NO_THREADS_DISCOVERY] (GC_DllMain): Call
GC_win32_dll_lookup_thread() and GC_delete_gc_thread_no_free() instead
of GC_delete_thread() (w/o a warning if the thread is not found).
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
This, at least, avoids "Removing nonexistent thread" warning
if GC_ExitThread or GC_endthreadex is called by client and
DllMain-based thread registration is on.
* win32_threads.c (GC_win32_start_inner): Add assertion that
GC_win32_dll_threads is off.
* win32_threads.c (GC_ExitThread): Do not call GC_unregister_my_thread
if GC_win32_dll_threads (because the thread is to be unregistered by
DllMain).
* win32_threads.c [!CYGWIN32 && !MSWINCE && !MSWIN_XBOX1 && !NO_CRT]
(GC_endthreadex): Likewise.
|
|
|
|
|
|
|
|
|
|
| |
* include/gc/gc.h [GC_THREADS] (GC_unregister_my_thread): Refine
comment (mention that GC_SUCCESS is always returned).
* tests/gctest.c [THREADS] (check_heap_stats): Cast call of
GC_unregister_my_thread() to void.
* win32_threads.c (GC_win32_start_inner, GC_ExitThread): Likewise.
* win32_threads.c [!CYGWIN32 && !MSWINCE && !MSWIN_XBOX1 && !NO_CRT]
(GC_endthreadex): Likewise.
|
|
|
|
|
|
|
|
|
| |
(fix of commit 7eb49a4e6)
Issue #362 (bdwgc).
* win32_threads.c (GC_start_world): Cast away volatile for
crtn->stack_end in the assertions.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
Issue #362 (bdwgc).
* darwin_stop_world.c (GC_stack_range_for): Define and crtn local
variable; use crtn instead of p to access stack_ptr, topOfStack,
stack_end, altstack, altstack_size, normstack, normstack_size,
backing_store_end, backing_store_ptr.
* pthread_stop_world.c [!NACL] (GC_suspend_handler_inner,
GC_push_all_stacks): Likewise.
* pthread_support.c [!GC_NO_FINALIZATION] (GC_reset_finalizer_nested,
GC_check_finalizer_nested): Likewise.
* pthread_support.c [!GC_WIN32_THREADS] (GC_register_altstack):
Likewise.
* pthread_support.c (do_blocking_enter, do_blocking_leave,
GC_set_stackbottom, GC_get_my_stackbottom, GC_call_with_gc_active):
Likewise.
* win32_threads.c (GC_push_stack_for, GC_get_next_stack): Likewise.
* darwin_stop_world.c (GC_push_all_stacks): Use p->crtn instead of p
to access traced_stack_sect.
* win32_threads.c (GC_suspend, GC_stop_world, GC_start_world):
Likewise.
* include/private/pthread_support.h (GC_StackContext_Rep): New struct
type (move dummy, stack_end, stack_ptr, last_stack_min,
initial_stack_base, topOfStack, backing_store_end, backing_store_ptr,
altstack, altstack_size, normstack, normstack_size, finalizer_nested,
finalizer_skipped, traced_stack_sect from GC_Thread_Rep).
* include/private/pthread_support.h [!GC_NO_THREADS_DISCOVERY
&& GC_WIN32_THREADS] (GC_StackContext_Rep.stack_end): Add volatile.
* include/private/pthread_support.h [!GC_NO_FINALIZATION]
(GC_StackContext_Rep.fnlz_pad): New field.
* include/private/pthread_support.h (GC_stack_context_t): New type.
* include/private/pthread_support.h (GC_Thread_Rep.crtn,
GC_Thread_Rep.flags_pad): New field.
* include/private/pthread_support.h [GC_NO_FINALIZATION]
(GC_Thread_Rep.no_fnlz_pad): Remove field.
* include/private/pthread_support.h (GC_threads): Move (and refine)
comment from GC_Thread_Rep.
* include/private/pthread_support.h [GC_WIN32_THREADS]
(GC_record_stack_base): Change me argument to crtn.
* pthread_stop_world.c [!NACL] (GC_store_stack_ptr): Likewise.
* pthread_support.c (GC_record_stack_base): Likewise.
* pthread_stop_world.c [NACL] (NACL_STORE_REGS, nacl_pre_syscall_hook,
__nacl_suspend_thread_if_needed): Use p->crtn instead of p to access
stack_ptr.
* pthread_support.c (first_crtn): New static variable.
* pthread_support.c (first_thread): Update comment.
* pthread_support.c (first_thread_used): Remove variable.
* pthread_support.c (GC_push_thread_structures): Push
first_thread.crtn symbol
* pthread_support.c (GC_push_thread_structures): Push
first_crtn.backing_store_end instead of that in first_thread.
* pthread_support.c [MPROTECT_VDB && GC_WIN32_THREADS]
(GC_win32_unprotect_thread): Call GC_remove_protection() for t->crtn.
* pthread_support.c (GC_new_thread): Use first_thread.crtn!=0 instead
of first_thread_used; set first_thread.crtn to &first_crtn; allocate
GC_StackContext_Rep object using GC_INTERNAL_MALLOC() and store the
pointer to result->crtn.
* pthread_support.c [CPPCHECK] (GC_new_thread): Call GC_noop1() for
first_thread.flags_pad, for first_crtn.dummy instead of result->dummy,
and for first_crtn.fnlz_pad instead of result->no_fnlz_pad.
* pthread_support.c (GC_delete_thread): Call GC_INTERNAL_FREE(p->crtn)
along with that for p.
* pthread_support.c [CAN_HANDLE_FORK && (!THREAD_SANITIZER
|| !CAN_CALL_ATFORK)] (GC_remove_all_threads_but_me): Likewise.
* pthread_support.c [GC_PTHREADS] (GC_pthread_join, GC_pthread_detach):
Likewise.
* pthread_support.c (GC_segment_is_thread_stack,
GC_greatest_stack_base_below): Use p->crtn instead of p to access
stack_end.
* pthread_support.c (GC_call_with_gc_active): Move assertions about me
fields to be after LOCK; add assertion that me->crtn==crtn.
* win32_threads.c (dll_thread_table): Make it static.
* win32_threads.c [!GC_NO_THREADS_DISCOVERY] (dll_crtn_table): New
static variable.
* win32_threads.c (GC_register_my_thread_inner): Reformat comment;
set me->crtn.
* win32_threads.c (GC_push_stack_for): Define stack_end local variable;
immediately return (zero) if stack_end is NULL.
* win32_threads.c (GC_push_all_stacks): Call GC_push_stack_for() (and
increment nthreads) even if stack_end is NULL.
* win32_threads.c (GC_get_next_stack): Rename s local variable to
stack_end.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(fix of commit bc1866b14)
Reproduced only if DEBUG_THREADS is defined.
Do not call GC_log_printf(), even indirectly from GC_stop_world() with
GC_write_cs acquired.
* pthread_support.c [DEBUG_THREADS] (GC_delete_thread,
GC_delete_gc_thread_no_free): Do not call GC_log_printf() if MSWINCE
or MSWIN32 and not CONSOLE_LOG.
* win32_threads.c [DEBUG_THREADS] (GC_suspend): Likewise.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* CMakeLists.txt [CMAKE_USE_PTHREADS_INIT
|| CMAKE_USE_WIN32_THREADS_INIT] (SRC): Include pthread_start.c and
pthread_support.c for Win32 platform.
* Makefile.am [THREADS] (libgc_la_SOURCES): Likewise.
* NT_MAKEFILE [ENABLE_STATIC] (OBJS): Add pthread_start.obj,
pthread_support.obj.
* include/private/gc_locks.h [LINT2 || GC_WIN32_THREADS]
(NO_PTHREAD_TRYLOCK): Do not define if already defined; add comment.
* include/private/gcconfig.h [GC_PTHREADS && !GC_PTHREADS_PARAMARK
&& !__MINGW32__] (GC_PTHREADS_PARAMARK): Do not define unless
PARALLEL_MARK.
* include/private/pthread_support.h (thread_id_self, THREAD_ID_EQUAL,
ADDR_LIMIT, MAX_MARKERS, GC_PTHREAD_PTRVAL): Define macro.
* include/private/pthread_support.h (GC_win32_dll_threads,
GC_available_markers_m1, GC_required_markers_cnt, GC_marker_sp,
GC_marker_last_stack_min, GC_marker_Id): Declare global variable.
* include/private/pthread_support.h (GC_init_win32_thread_naming,
GC_mark_thread, GC_new_thread, GC_record_stack_base,
GC_register_my_thread_inner, GC_lookup_by_pthread, GC_setup_atfork,
GC_win32_cache_self_pthread, GC_delete_gc_thread_no_free,
GC_win32_dll_lookup_thread, GC_delete_thread,
GC_win32_unprotect_thread, GC_wait_for_gc_completion): Declare.
* include/private/pthread_support.h [GC_PTHREADS]
(GC_pthread_start_inner, GC_start_rtn_prepare_thread): Declare even for
GC_WIN32_THREADS.
* misc.c [!THREADS] (GC_call_with_gc_active, GC_do_blocking_inner):
Update comment to refer to pthread_support.c.
* pthread_start.c [GC_PTHREADS] (GC_pthread_start_inner): Define even
for GC_WIN32_THREADS.
* pthread_support.c: Do not skip this file for GC_WIN32_THREADS;
adjust includes for Win32.
* pthread_support.c (GC_INNER_WIN32THREAD): New macro.
* pthread_support.c (GC_init_win32_thread_naming,
GC_win32_unprotect_thread): New function.
* pthread_support.c (setThreadDescription_fn, set_marker_thread_name):
Move from win32_threads.c.
* pthread_support.c (available_markers_m1): Rename to
GC_available_markers_m1.
* win32_threads.c (available_markers_m1): Likewise.
* pthread_support.c (required_markers_cnt): Rename to
GC_required_markers_cnt.
* win32_threads.c (required_markers_cnt): Likewise.
* pthread_support.c (GC_mark_thread, GC_start_mark_threads_inner,
GC_push_thread_structures, GC_count_threads, GC_new_thread,
GC_delete_thread, GC_delete_gc_thread_no_free, GC_lookup_thread,
GC_reset_finalizer_nested, GC_check_finalizer_nested,
GC_is_thread_tsd_valid, GC_thread_is_registered, GC_register_altstack,
GC_segment_is_thread_stack, GC_wait_for_gc_completion,
GC_remove_all_threads_but_me, fork_child_proc, GC_record_stack_base,
GC_init_parallel, GC_pthread_sigmask, GC_set_stackbottom,
GC_get_my_stackbottom, GC_call_with_gc_active, GC_unregister_my_thread,
GC_unregister_my_thread_inner, GC_thread_exit_proc, GC_pthread_join,
GC_pthread_detach, GC_pthread_sigmask, GC_pthread_create): Adjust
function for Win32.
* win32_threads.c (GC_lock_holder, GC_win32_dll_threads, IE_t,
GC_thr_initialized, GC_need_to_lock, ADDR_LIMIT, GC_thread,
GC_vthread, GC_threads, first_thread, GC_new_thread,
GC_in_thread_creation, GC_record_stack_base, GC_lookup_thread,
CHECK_LOOKUP_MY_THREAD, GC_reset_finalizer_nested,
GC_check_finalizer_nested, GC_is_thread_tsd_valid,
GC_thread_is_registered, GC_register_altstack, UNPROTECT_THREAD,
GC_PTHREAD_PTRVAL, GC_delete_gc_thread_no_free, GC_delete_thread,
GC_allow_register_threads, GC_register_my_thread, GC_set_stackbottom,
GC_wait_for_gc_completion, GC_unregister_my_thread,
GC_do_blocking_inner, GC_call_with_gc_active, GC_get_my_stackbottom,
GC_remove_all_threads_but_me, fork_prepare_proc, fork_parent_proc,
fork_child_proc, GC_atfork_prepare, GC_atfork_parent, GC_atfork_child,
GC_setup_atfork, GC_push_thread_structures, marker_sp,
set_marker_thread_name, setThreadDescription_fn, GC_mark_thread,
required_markers_cnt, GC_set_markers_count, START_MARK_THREADS,
start_info, GC_pthread_join, GC_pthread_create, GC_pthread_start_inner,
GC_pthread_start, GC_thread_exit_proc, GC_pthread_detach, GC_check_tls,
GC_init_parallel, GC_lock, GC_mark_thread_local_free_lists): Remove.
* win32_threads.c [GC_PTHREADS_PARAMARK] (mark_cv,
GC_start_mark_threads_inner, GC_mark_lock_holder, SET_MARK_LOCK_HOLDER,
UNSET_MARK_LOCK_HOLDER, mark_mutex, builder_cv, GC_acquire_mark_lock,
GC_release_mark_lock, GC_wait_builder, GC_wait_for_reclaim,
GC_notify_all_builder, GC_wait_marker, GC_notify_all_marker,
* win32_threads.c [GC_PTHREADS] (pthread_create, pthread_join,
pthread_detach, pthread_sigmask): Do not undefine.
* win32_threads.c [CAN_CALL_ATFORK]: Do not include unistd.h.
* win32_threads.c (GC_register_my_thread_inner): Change type of me
local variable from GC_vthread to GC_thread.
* win32_threads.c (GC_win32_dll_lookup_thread,
GC_win32_cache_self_pthread): New GC_INNER function.
* win32_threads.c (GC_suspend, GC_start_world, GC_push_stack_for): Use
GC_win32_unprotect_thread() instead of UNPROTECT_THREAD().
* win32_threads.c (marker_last_stack_min): Rename to
GC_marker_last_stack_min.
* win32_threads.c (GC_thr_init): Call GC_init_win32_thread_naming().
|
|
|
|
|
|
|
|
|
|
| |
(fix of commit 95947bdc5)
* pthread_support.c [PARALLEL_MARK && !NO_MARKER_SPECIAL_SIGMASK]
(GC_start_mark_threads_inner): Do not pass errno value to WARN() calls
(because pthread_sigmask does not set errno).
* win32_threads.c [PARALLEL_MARK && GC_PTHREADS_PARAMARK
&& !NO_MARKER_SPECIAL_SIGMASK] (GC_start_mark_threads_inner): Likewise.
|
|
|
|
|
|
|
|
|
|
|
|
| |
* pthread_support.c [HAVE_PTHREAD_SETNAME_NP_WITH_TID_AND_ARG]
(set_marker_thread_name): Cast WARN argument to signed_word.
* pthread_support.c [PARALLEL_MARK] (GC_start_mark_threads_inner):
Likewise.
* pthread_support.c [GC_LINUX_THREADS && !HOST_ANDROID && !NACL]
(GC_get_nprocs): Likewise.
* pthread_support.c (GC_thr_init): Likewise.
* win32_threads.c [PARALLEL_MARK] (GC_start_mark_threads_inner):
Likewise.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
Issue #496 (bdwgc).
WARN_PRIuPTR is now used to print unsigned values in WARN() calls.
Also, byte values are replaced with KiB ones in some WARN() calls.
* allchblk.c (GC_allochblk_nth): Use WARN_PRIuPTR specifier instead of
WARN_PRIdPTR.
* alloc.c (GC_expand_hp_inner, GC_collect_or_expand): Likewise.
* headers.c (GC_scratch_alloc): Likewise.
* mark.c (alloc_mark_stack): Likewise.
* misc.c (GC_enable): Likewise.
* os_dep.c [NEED_PROC_MAPS] (GC_get_maps): Likewise.
* os_dep.c [PROC_VDB] (GC_proc_read_dirty): Likewise.
* win32_threads.c (GC_delete_thread): Likewise.
* allchblk.c (GC_allochblk_nth): Print KiB value instead of in bytes
in WARN message.
* alloc.c (GC_expand_hp_inner): Likewise.
* misc.c (GC_enable): Likewise.
* alloc.c (GC_expand_hp_inner): Remove unneeded cast of bytes to word.
* headers.c (GC_scratch_alloc): Likewise.
* alloc.c [(!AMIGA || !GC_AMIGA_FASTALLOC) && USE_MUNMAP]
(GC_collect_or_expand): Add assertion to indicate that there is no
underflow in GC_heapsize-GC_unmapped_bytes.
* include/private/gc_priv.h (WARN): Update comment.
* include/private/gc_priv.h [!WARN_PRIdPTR] (WARN_PRIuPTR): Define.
|
|
|
|
|
|
|
|
| |
(fix of commit 6b2980ab6)
* win32_threads.c [PARALLEL_MARK && GC_PTHREADS_PARAMARK
&& GC_ASSERTIONS] (NUMERIC_THREAD_ID): Define only if USE_PTHREAD_LOCKS
is not defined (instead of checking NUMERIC_THREAD_ID).
|
|
|
|
|
|
|
|
|
|
| |
(fix of commit d692eb432)
* pthread_support.c (GC_thr_init): Put &GC_threads into parentheses in
assertion.
* win32_threads.c (GC_thr_init): Likewise.
* thread_local_alloc.c [USE_CUSTOM_SPECIFIC] (GC_init_thread_local):
Put &GC_thread_key into parentheses in assertion.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* pthread_support.c [CAN_HANDLE_FORK] (store_to_threads_table,
GC_remove_all_threads_but_me): Move definition down (to be close to
fork_prepare_proc).
* pthread_support.c [CAN_HANDLE_FORK]: Reformat comment; adjust code
indentation.
* pthread_support.c [CAN_HANDLE_FORK] (GC_setup_atfork): New STATIC
function (move code from GC_thr_init).
* win32_threads.c [CAN_HANDLE_FORK] (GC_setup_atfork): Likewise.
* pthread_support.c [CAN_HANDLE_FORK] (GC_thr_init): Call
GC_setup_atfork().
* win32_threads.c [CAN_HANDLE_FORK] (GC_thr_init): Likewise.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
This is to match the code (naming style) of pthread_support.c file.
* win32_threads.c [!GC_NO_THREADS_DISCOVERY] (GC_main_thread): Rename
to main_thread_id; change STATIC to static.
* win32_threads.c (thread_args): Rename win32_start_info; rename start
field to start_routine; rename param field to arg.
* win32_threads.c (GC_win32_start_inner): Rename start local variable
to start_routine; rename param local variable to start_arg; rename
args local variable to psi.
* win32_threads.c [!CYGWIN32 && !MSWINCE && !MSWIN_XBOX1 && !NO_CRT]
(GC_beginthreadex): Likewise.
* win32_threads.c [GC_WINMAIN_REDIRECT] (main_thread_start): Rename
args local variable to main_args.
* win32_threads.c (GC_thr_init): Use main_thread_id variable instead
of GC_main_thread.
* win32_threads.c [!GC_PTHREADS && !GC_NO_THREADS_DISCOVERY]
(GC_DllMain): Likewise.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* include/private/gc_locks.h [GC_WIN32_THREADS && !USE_PTHREAD_LOCKS
|| GC_PTHREADS] (NO_THREAD): Define in a single place.
* include/private/gc_locks.h [(GC_WIN32_THREADS && !USE_PTHREAD_LOCKS
|| GC_PTHREADS) && GC_ASSERTIONS] (UNSET_LOCK_HOLDER): Likewise.
* include/private/gc_locks.h [(GC_WIN32_THREADS && !USE_PTHREAD_LOCKS
|| GC_PTHREADS) && GC_ASSERTIONS] (GC_lock_holder): Declare in a single
place.
* include/private/gc_locks.h [GC_WIN32_THREADS && !USE_PTHREAD_LOCKS]
(NO_THREAD): Change DWORD to unsigned long.
* include/private/gc_locks.h [GC_WIN32_THREADS && !USE_PTHREAD_LOCKS
&& GC_ASSERTIONS] (GC_lock_holder): Likewise.
* win32_threads.c [!USE_PTHREAD_LOCKS && GC_ASSERTIONS]
(GC_lock_holder): Likewise.
* win32_threads.c [PARALLEL_MARK && !GC_PTHREADS_PARAMARK
&& GC_ASSERTIONS] (GC_mark_lock_holder): Likewise.
* include/private/gc_locks.h [(GC_WIN32_THREADS && !USE_PTHREAD_LOCKS
|| GC_PTHREADS) && GC_ASSERTIONS] (SET_LOCK_HOLDER, UNSET_LOCK_HOLDER):
Cast to void.
* win32_threads.c [GC_ASSERTIONS] (GC_lock_holder): Define in a single
place (in the file).
|
|
|
|
|
|
|
|
|
|
| |
* win32_threads.c [THREAD_LOCAL_ALLOC] (GC_register_my_thread_inner):
Update comment; do not call GC_init_thread_local().
* win32_threads.c [THREAD_LOCAL_ALLOC] (GC_register_my_thread): Call
GC_init_thread_local() both after GC_register_my_thread_inner() and
GC_record_stack_base() calls (in case of return GC_SUCCESS).
* win32_threads.c [GC_PTHREADS && THREAD_LOCAL_ALLOC]
(GC_pthread_start_inner): Call GC_init_thread_local().
|
|
|
|
|
|
|
|
|
| |
* pthread_support.c (pthread_create): Call ABORT() if
pthread_attr_getdetachstate() has failed.
* win32_threads.c [GC_PTHREADS] (GC_pthread_create): Likewise.
* win32_threads.c [GC_PTHREADS] (start_info.detached): Change type from
GC_bool to int (to match the type of the 2nd argument of
pthread_attr_getdetachstate).
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* pthread_support.c [PARALLEL_MARK] (GC_mark_threads): Remove static
variable.
* pthread_support.c [PARALLEL_MARK] (GC_start_mark_threads_inner):
Define new_thread local variable and use it in pthread_create() call
instead of GC_mark_threads.
* win32_threads.c [PARALLEL_MARK]: Remove comment about
GC_mark_threads.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* include/private/pthread_support.h: Add title comment.
* include/private/pthread_support.h: Replace
GC_PTHREADS&&!GC_WIN32_THREADS condition to THREADS.
* include/private/pthread_support.h [GC_PTHREADS
|| GC_PTHREADS_PARAMARK]: Include pthread.h.
* include/private/pthread_support.h [GC_WIN32_THREADS] (thread_id_t):
Define as DWORD.
* include/private/pthread_support.h [!GC_NO_THREADS_DISCOVERY
&& GC_WIN32_THREADS] (GC_Thread_Rep.tm): Add in_use and long_in_use
union fields (moved from win32_threads.c).
* include/private/pthread_support.h (GC_Thread_Rep.tm.next,
GC_Thread_Rep.stack_end): Update comment.
* include/private/pthread_support.h (GC_Thread_Rep.id): Add comment.
* include/private/pthread_support.h [USE_TKILL_ON_ANDROID]
(GC_Thread_Rep.kernel_id): Move field down (to be after stack_ptr).
* include/private/pthread_support.h [GC_WIN32_THREADS && GC_PTHREADS]
(GC_Thread_Rep.pthread_id): New field (moved from win32_threads.c).
* include/private/pthread_support.h [GC_NO_FINALIZATION]
(GC_Thread_Rep.no_fnlz_pad): Likewise.
* include/private/pthread_support.h [GC_WIN32_THREADS]
(GC_Thread_Rep.last_stack_min): Likewise.
* include/private/pthread_support.h [GC_WIN32_THREADS && I386]
(GC_Thread_Rep.initial_stack_base): Likewise.
* include/private/pthread_support.h [GC_WIN32_THREADS && !MSWINCE]
(GC_Thread_Rep.handle): Likewise.
* include/private/pthread_support.h [RETRY_GET_THREAD_CONTEXT]
(GC_Thread_Rep.context_sp, GC_Thread_Rep.context_regs): Likewise.
* include/private/pthread_support.h (GC_Thread_Rep.flags): Move field
up (to be right after pthread_id one).
* include/private/pthread_support.h (FINISHED, DETACHED, MAIN_THREAD,
DISABLED_GC, DO_BLOCKING, KNOWN_FINISHED): Move macro definition up
to stay close to flags field.
* include/private/pthread_support.h [!GC_PTHREADS] (KNOWN_FINISHED):
Define to FALSE.
* include/private/pthread_support.h (DETACHED): Define only if
GC_PTHREADS.
* include/private/pthread_support.h (GC_Thread_Rep.status): Likewise.
* include/private/pthread_support.h (MAIN_THREAD, DISABLED_GC): Do not
define if GC_WIN32_THREADS.
* include/private/pthread_support.h (GC_Thread_Rep.altstack,
GC_Thread_Rep.altstack_size, GC_Thread_Rep.normstack,
GC_Thread_Rep.normstack_size): Likewise.
* include/private/pthread_support.h [GC_WIN32_THREADS] (IS_SUSPENDED):
Define macro (moved from win32_threads.c).
* include/private/pthread_support.h [MSWINCE || GC_WIN32_THREADS]
(THREAD_HANDLE): Likewise.
* include/private/pthread_support.h [GC_WIN32_THREADS]
(THREAD_TABLE_INDEX): Likewise.
* include/private/gcconfig.h [GC_WIN32_THREADS] (PUSHED_REGS_COUNT):
Likewise.
* include/private/gcconfig.h [GC_PTHREADS && !GC_PTHREADS_PARAMARK
&& !__MINGW32__] (GC_PTHREADS_PARAMARK): Likewise.
* include/private/pthread_support.h [!GC_NO_FINALIZATION]
(GC_Thread_Rep.finalizer_nested, GC_Thread_Rep.finalizer_skipped): Move
field up to be right after flags one.
* include/private/pthread_support.h [SIGNAL_BASED_STOP_WORLD]
(GC_Thread_Rep.last_stop_count, GC_Thread_Rep.ext_suspend_cnt):
Reformat comment.
* include/private/pthread_support.h (GC_Thread_Rep.traced_stack_sect):
Likewise.
* include/private/pthread_support.h (GC_inner_start_routine,
GC_start_rtn_prepare_thread): Do not declare if GC_WIN32_THREADS.
* include/private/pthread_support.h (GC_thread_exit_proc): Declare only
if GC_PTHREADS.
* pthread_start.c: Do not include pthread.h.
* pthread_support.c: Likewise.
* win32_threads.c [GC_PTHREADS || GC_WIN32_PTHREADS
|| GC_PTHREADS_PARAMARK]: Likewise.
* win32_threads.c: Include pthread_support.h instead of gc_priv.h.
* win32_threads.c [THREAD_LOCAL_ALLOC]: Do not include
thread_local_alloc.h directly.
* win32_threads.c [GC_PTHREADS] (GC_thread_exit_proc): Remove static
function declaration.
* win32_threads.c [GC_ASSERTIONS] (GC_thr_initialized, GC_threads,
GC_lookup_thread_inner): Change STATIC to GC_INNER.
* win32_threads.c (thread_id_t, GC_Thread_Rep, THREAD_TABLE_SZ,
THREAD_TABLE_INDEX, PUSHED_REGS_COUNT, GC_PTHREADS_PARAMARK): Do not
define.
* win32_threads.c (GC_lookup_thread_inner): Rename to GC_lookup_thread.
* win32_threads.c [GC_PTHREADS] (GC_lookup_pthread): Rename to
GC_lookup_by_pthread.
* win32_threads.c [GC_PTHREADS] (GC_thread_exit_proc): Change STATIC to
GC_INNER_PTHRSTART.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* darwin_stop_world.c (GC_use_threads_discovery): Do not check
DARWIN_DONT_PARSE_STACK.
* include/private/gcconfig.h [!GC_NO_THREADS_DISCOVERY]
(GC_NO_THREADS_DISCOVERY): Define macro (where the mode is
unsupported); move comment from win32_threads.c.
* include/private/gcconfig.h [GC_DISCOVER_TASK_THREADS
&& GC_NO_THREADS_DISCOVERY && !CPPCHECK]: Issue error.
* win32_threads.c: Replace ((GC_DLL||GC_INSIDE_DLL) && !NO_CRT
&& !GC_NO_THREADS_DISCOVERY && !MSWINCE && !THREAD_LOCAL_ALLOC
&& !GC_PTHREADS) with !GC_NO_THREADS_DISCOVERY.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* win32_threads.c (thread_id_t): Define type.
* win32_threads.c (GC_Thread_Rep.id, GC_main_thread,
GC_pthread_map_cache): Change type from DWORD to thread_id_t.
* win32_threads.c [PARALLEL_MARK && !GC_PTHREADS_PARAMARK]
(GC_marker_Id): Likewise.
* win32_threads.c (GC_Thread_Rep.stack_base): Rename to stack_end;
update comment.
* win32_threads.c (GC_Thread_Rep.thread_blocked_sp): Rename to
stack_ptr; update comment.
* win32_threads.c [GC_NO_FINALIZATION] (GC_Thread_Rep.no_fnlz_pad):
New field (to force word-aligned next fields).
* win32_threads.c (GC_Thread_Rep.suspended): Remove (use flags and
IS_SUSPENDED instead).
* win32_threads.c (GC_Thread_Rep.flags, FINISHED): Define even if not
GC_PTHREADS.
* win32_threads.c (GC_new_thread, GC_register_my_thread_inner,
GC_register_my_thread_inner, GC_delete_thread): Rename thread_id to id
and change its type from DWORD to thread_id_t.
* win32_threads.c (GC_thread_is_registered, GC_register_my_thread,
GC_unregister_my_thread, GC_do_blocking_inner, GC_call_with_gc_active,
GC_get_my_stackbottom, GC_remove_all_threads_but_me, GC_stop_world,
GC_start_world, GC_push_all_stacks, GC_pthread_start_inner,
GC_DllMain): Rename thread_id local variable to self_id and change its
type from DWORD to thread_id_t.
* win32_threads.c [PARALLEL_MARK && !GC_PTHREADS_PARAMARK]
(GC_wait_marker, GC_notify_all_marker): Likewise.
* win32_threads.c (GC_new_thread): Remove comment about the pthreads
version; assert result->flags is zero even if not GC_PTHREADS; do not
use thread_blocked_sp.
* win32_threads.c [GC_NO_FINALIZATION && CPPCHECK] (GC_new_thread):
Call GC_noop1(result->no_fnlz_pad[0]).
* win32_threads.c (GC_record_stack_base): Change me argument type from
GC_vthread to GC_thread.
* win32_threads.c (GC_delete_gc_thread_no_free): Remove id local
variable.
* win32_threads.c [GC_PTHREADS] (GC_register_my_thread,
GC_remove_all_threads_but_me, GC_pthread_join, GC_pthread_detach):
Replace p->flags&FINISHED to KNOWN_FINISHED(p).
* win32_threads.c [IA64] (GC_do_blocking_inner): Rename stack_ptr local
variable to bs_hi.
* win32_threads.c (GC_do_blocking_inner, GC_call_with_gc_active,
GC_set_stackbottom, GC_stop_world, GC_push_stack_for):
Replace p->thread_blocked_sp to p->flags&DO_BLOCKING.
* win32_threads.c (GC_do_blocking_inner, GC_call_with_gc_active): Do
not set p->stack_ptr to NULL.
* win32_threads.c [GC_PTHREADS] (GC_lookup_pthread): Rename id argument
to thread.
* win32_threads.c [GC_PTHREADS && CAN_HANDLE_FORK]
(GC_remove_all_threads_but_me, GC_pthread_start_inner): Rename
pthread_id local variable to self.
* win32_threads.c (GC_push_stack_for): Rename me argument to self_id
and change its type from DWORD to thread_id_t.
* win32_threads.c (GC_stop_world, GC_start_world, GC_push_stack_for):
Replace p->suspended with p->flags&IS_SUSPENDED.
* win32_threads.c [GC_PTHREADS] (GC_pthread_join, GC_pthread_detach):
Rename pthread_id argument to thread.
|
|
|
|
|
|
|
| |
(fix of commit 48a01ee1c)
* win32_threads.c [GC_PTHREADS] (GC_lookup_pthread): Move hv local
variable definition to the inner block where it is used.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* darwin_stop_world.c [DARWIN_DONT_PARSE_STACK] (GC_stack_range_for):
Rename p->stack[_size] to p->normstack[_size].
* pthread_support.c (GC_thr_init): Likewise.
* include/gc/gc.h (GC_register_altstack): Rename stack_start to
normstack and stack_size to normstack_size in comment, respectively.
* include/private/pthread_support.h (GC_Thread_Rep.stack): Rename to
normstack.
* include/private/pthread_support.h (GC_Thread_Rep.stack_size): Rename
to normstack_size.
* pthread_support.c (main_stack): Rename to main_normstack.
* pthread_support.c (main_stack_size): Rename to main_normstack_size.
* pthread_support.c (GC_register_altstack): Rename stack to normstack
and stack_size to normstack_size arguments, respectively.
* win32_threads.c (GC_register_altstack): Likewise.
* pthread_support.c [(HAVE_PTHREAD_ATTR_GET_NP
|| HAVE_PTHREAD_GETATTR_NP) && IA64]: Change stack_base to "stack base"
in comment.
|
|
|
|
| |
* win32_threads.c (dll_thread_table): Fix a typo ("use") in comment.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
Also, change "while" to "for" statement to iterate over GC_threads.
* darwin_stop_world.c (GC_stack_range_for): Add pfound_me argument;
update comment; set *pfound_me to TRUE if thread is my_thread.
* win32_threads.c (GC_push_stack_for): Likewise.
* darwin_stop_world.c (GC_push_all_stacks): Do not define listcount
local variable if DARWIN_DONT_PARSE_STACK.
* darwin_stop_world.c (GC_push_all_stacks): Pass &found_me to
GC_stack_range_for (instead of setting it to TRUE directly).
* win32_threads.c (GC_push_all_stacks): Likewise.
* darwin_stop_world.c [DARWIN_DONT_PARSE_STACK] (GC_push_all_stacks):
Do not initialize act_list and listcount local variables.
* pthread_stop_world.c [!NACL && !GC_OPENBSD_UTHREADS
&& THREAD_SANITIZER] (GC_lookup_thread_async): Change while statement
to for one.
* pthread_support.c [DEBUG_THREADS] (GC_count_threads): Likewise.
* pthread_support.c (GC_lookup_thread): Likewise.
* win32_threads.c (GC_lookup_thread_inner, GC_delete_thread): Likewise.
* pthread_stop_world.c (GC_push_all_stacks): Define and use is_self
local variable.
* win32_threads.c (GC_push_stack_for): Likewise.
* pthread_support.c [DEBUG_THREADS] (GC_count_threads): Rename th
local variable to p.
* win32_threads.c (GC_Thread_Rep.thread_blocked_sp,
GC_lookup_pthread): Refine comment.
* win32_threads.c (GC_new_thread, GC_delete_thread): Rename id
argument to thread_id.
* win32_threads.c (GC_lookup_pthread): Remove GC_lookup_pthread label.
* win32_threads.c (GC_lookup_thread_inner): Reformat comment.
* win32_threads.c [!GC_NO_THREADS_DISCOVERY] (GC_lookup_thread_inner):
Define and use t local variable.
* win32_threads.c (GC_stop_world, GC_start_world, GC_push_all_stacks,
GC_get_next_stack): Rename t to p local variable.
* win32_threads.c [!GC_NO_THREADS_DISCOVERY] (GC_stop_world): Change
type of t local from GC_vthread to GC_thread.
|
|
|
|
|
|
|
| |
(fix of commit 6713d8473)
* win32_threads.c [GC_WINMAIN_REDIRECT]
(GC_waitForSingleObjectInfinite): Add GC_CALLBACK.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* include/private/gc_priv.h [WRAP_MARK_SOME]: Replace
!MSWIN32&&!MSWINCE||__GNUC__ to NO_SEH_AVAILABLE in ifdef.
* mark.c [WRAP_MARK_SOME] (GC_mark_some): Likewise.
* os_dep.c [WRAP_MARK_SOME] (GC_fault_handler_t, GC_jmp_buf): Likewise.
* include/private/gcconfig.h [!MSWIN32 && !MSWINCE || __GNUC__
|| NO_CRT] (NO_SEH_AVAILABLE): Define.
* mark.c [WRAP_MARK_SOME] (GC_mark_some): Refine comments.
* os_dep.c (MIN_PAGE_SIZE): Define regardless of WRAP_MARK_SOME.
* win32_threads.c (GC_win32_start_inner): Replace !__GNUC__&&!NO_CRT
to !NO_SEH_AVAILABLE in ifdef.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
* ChangeLog: Replace i386 and X86 to x86; replace x86_64 and amd64 to
x64; replace "Win32 pthreads" to pthreads-win32; lower case win32s,
x86, x64; replace win32 to Win32; replace "MS Windows" to Windows (in
documentation and comments).
* NT_MAKEFILE: Likewise.
* README.md: Likewise.
* configure.ac: Likewise.
* cord/tests/de_win.c: Likewise.
* doc/README.macros: Likewise.
* doc/README.solaris2: Likewise.
* doc/README.win32: Likewise.
* doc/README.win64: Likewise.
* doc/debugging.md: Likewise.
* doc/leak.md: Likewise.
* doc/overview.md: Likewise.
* doc/porting.md: Likewise.
* extra/msvc_dbg.c: Likewise.
* finalize.c: Likewise.
* include/gc/cord.h: Likewise.
* include/gc/gc.h: Likewise.
* include/private/gc_priv.h: Likewise.
* include/private/gcconfig.h: Likewise.
* include/private/pthread_stop_world.h: Likewise.
* mach_dep.c: Likewise.
* mark.c: Likewise.
* mark_rts.c: Likewise.
* misc.c: Likewise.
* os_dep.c: Likewise.
* tools/threadlibs.c: Likewise.
* win32_threads.c: Likewise.
* cord/tests/de.c (WIN32): Remove misleading comment.
* misc.c (GC_enable_incremental): Change comment about win32s to TODO
item.
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* win32_threads.c [GC_PTHREADS && !GC_NO_THREADS_DISCOVERY]
(GC_lookup_pthread): Remove unreachable code (because GC_PTHREADS
implies GC_NO_THREADS_DISCOVERY, as of now); add TODO to re-add the
code when threads discovery will be supported with pthreads.
|
|
|
|
|
|
|
|
|
|
| |
(fix of commit 2fe9e9d55)
Break the loop (over dll_thread_table elements) in GC_lookup_pthread
when pthread_id matches id (provided the element is in use).
* win32_threads.c [GC_PTHREADS && !GC_NO_THREADS_DISCOVERY]
(GC_lookup_pthread): Inverse THREAD_EQUAL() condition in for statement.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* CMakeLists.txt [BORLAND] (add_compile_options): Remove "/w-par";
reorder options.
* CMakeLists.txt [!BORLAND && MSVC] (add_compile_options): Remove
"/wd4100"; update comment.
* NT_MAKEFILE (.c.obj): Likewise.
* allchblk.c [!NO_DEBUGGING || GC_ASSERTIONS] (add_hb_sz): Use
UNUSED_ARG() instead of GC_ATTR_UNUSED.
* allchblk.c [USE_MUNMAP] (GC_adjust_num_unmapped): Likewise.
* backgraph.c [MAKE_BACK_GRAPH] (pop_in_progress, reset_back_edge,
update_max_height): Likewise.
* checksums.c [CHECKSUMS] (GC_add_block): Likewise.
* darwin_stop_world.c (GC_stack_range_for): Likewise.
* dbg_mlc.c (GC_store_debug_info_inner, GC_debug_change_stubborn,
GC_check_heap_block): Likewise.
* finalize.c [!GC_NO_FINALIZATION] (GC_null_finalize_mark_proc):
Likewise.
* gcj_mlc.c [GC_GCJ_SUPPORT] (GC_gcj_fake_mark_proc): Likewise.
* mallocx.c [!CPPCHECK] (GC_change_stubborn): Likewise.
* mark.c (GC_noop6, clear_marks_for_block): Likewise.
* mark.c [WRAP_MARK_SOME && (MSWIN32 || MSWINCE) && __GNUC__]
(mark_ex_handler): Likewise.
* mark.c [GC_DISABLE_INCREMENTAL] (GC_push_conditional): Likewise.
* mark_rts.c (GC_push_current_stack, GC_push_roots): Likewise.
* misc.c (GC_default_oom_fn, GC_set_handle_fork): Likewise.
* misc.c [THREADS && !SIGNAL_BASED_STOP_WORLD] (GC_set_suspend_signal,
GC_set_thr_restart_signal): Likewise.
* misc.c [THREADS && UNIX_LIKE && !NO_GETCONTEXT]
(callee_saves_pushed_dummy_fn): Likewise.
* misc.c [!THREADS] (GC_do_blocking_inner): Likewise.
* misc.c [!PARALLEL_MARK] (GC_set_markers_count): Likewise.
* os_dep.c [OPENBSD] (GC_fault_handler_openbsd): Likewise.
* os_dep.c [NEED_FIND_LIMIT || WRAP_MARK_SOME && !MSWIN32 && !MSWINCE
|| USE_PROC_FOR_LIBRARIES && THREADS] (GC_fault_handler): Likewise.
* os_dep.c [!HAVE_GET_STACK_BASE && !NEED_FIND_LIMIT]
(GC_get_stack_base): Likewise.
* os_dep.c [MPROTECT_VDB && DARWIN] (catch_exception_raise_state,
catch_exception_raise_state_identity, catch_exception_raise): Likewise.
* pthread_stop_world.c [!NACL && !GC_OPENBSD_UTHREADS
&& !SUSPEND_HANDLER_NO_CONTEXT] (GC_suspend_sigaction): Likewise.
* pthread_stop_world.c [!NACL && !GC_OPENBSD_UTHREADS]
(GC_suspend_handler_inner): Likewise.
* pthread_support.c (GC_do_blocking_inner): Likewise.
* pthread_support.c [GC_ENABLE_SUSPEND_THREAD
&& SIGNAL_BASED_STOP_WORLD] (GC_suspend_self_blocked): Likewise.
* tests/gctest.c [!DBG_HDRS_ALL] (fail_proc1): Likewise.
* tests/gctest.c [(MSWIN32 && !__MINGW32__ || MSWINCE)
&& !NO_WINMAIN_ENTRY] (WinMain): Likewise.
* tests/gctest.c [!PCR && !GC_WIN32_THREADS && !GC_PTHREADS
&& CPPCHECK && RTEMS] (Init): Likewise.
* tests/gctest.c [GC_WIN32_THREADS && !GC_PTHREADS] (thr_run_one_test):
Likewise.
* tests/gctest.c [MSWINCE] (thr_window): Likewise.
* tests/gctest.c [GC_PTHREADS] (thr_run_one_test): Likewise.
* typd_mlc.c (GC_array_mark_proc): Likewise.
* win32_threads.c (GC_register_altstack, GC_do_blocking_inner):
Likewise.
* win32_threads.c [!GC_PTHREADS && !GC_NO_THREADS_DISCOVERY]
(GC_DllMain): Likewise.
* cord/cordxtra.c (CORD_ATTR_UNUSED): Remove.
* include/private/gc_priv.h [!GC_ATTR_UNUSED] (GC_ATTR_UNUSED):
Likewise.
* cord/cordxtra.c (CORD_nul_func): Cast unused argument to void instead
of using CORD_ATTR_UNUSED.
* cord/cordxtra.c [!GC_NO_FINALIZATION] (CORD_lf_close_proc): Likewise.
* include/private/gc_priv.h [!UNUSED_ARG] (UNUSED_ARG): Define macro.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
If the collector is built with parallel marker support then marking
is performed in parallel on multi-core targets. Thus, if the client
provides custom mark procedures, then they could be executed in
parallel. In case of a single-threaded client (developed for the
older libgc version with the parallel mark support off), its custom
mark procedures might not be prepared to be launched in parallel.
Now, the parallel mark threads are not launched, even if available,
until the client starts a (user) thread (e.g. calls pthread_create or
GC_allow_register_threads) or tells the collector explicitly to start
the mark threads (by calling GC_start_mark_threads).
* doc/README.macros (GC_ALWAYS_MULTITHREADED): Update documentation.
* doc/scale.md (Options for enhanced scalability): Likewise.
* include/gc/gc.h [GC_THREADS] (GC_parallel,
GC_allow_register_threads): Update comment.
* include/gc/gc.h (GC_set_markers_count, GC_start_mark_threads):
Likewise.
* include/gc/gc_mark.h (GC_mark_proc): Likewise.
* include/gc/gc_mark.h (GC_PROC_BYTES, GC_ms_entry): Move upper to be
before the comment belonging to GC_mark_proc.
* misc.c [THREADS && PARALLEL_MARK] (GC_init): Do not call
GC_start_mark_threads_inner().
* misc.c [PARALLEL_MARK] (GC_start_mark_threads): Call
GC_start_mark_threads_inner() even if THREAD_SANITIZER or
no CAN_HANDLE_FORK.
* misc.c [THREADS] (GC_get_parallel): Remove comment.
* pthread_support.c [PARALLEL_MARK && !CAN_HANDLE_FORK]
(available_markers_m1): Define as a variable.
* win32_threads.c [PARALLEL_MARK && !CAN_HANDLE_FORK]
(available_markers_m1): Likewise.
* pthread_support.c [PARALLEL_MARK && !CAN_HANDLE_FORK]
(GC_wait_for_gc_completion): Declare.
* pthread_support.c [PARALLEL_MARK && !CAN_HANDLE_FORK]
(GC_start_mark_threads_inner): If GC_parallel then return; call
GC_wait_for_gc_completion(); set GC_markers_m1 value from
available_markers_m1.
* win32_threads.c [PARALLEL_MARK && (!GC_PTHREADS_PARAMARK
|| !CAN_HANDLE_FORK)] (GC_start_mark_threads_inner): Likewise.
* pthread_support.c [CAN_HANDLE_FORK && PARALLEL_MARK
&& THREAD_SANITIZER] (fork_child_proc): Set available_markers_m1 to 0.
* pthread_support.c [CAN_HANDLE_FORK]: Move
GC_remove_all_threads_but_me() call to be after setting
available_markers_m1.
* pthread_support.c (GC_allow_register_threads): Call
GC_start_mark_threads().
* tests/middle.c (main): Likewise.
* win32_threads.c (GC_allow_register_threads): Likewise.
* pthread_support.c [PARALLEL_MARK] (pthread_create): Call
GC_start_mark_threads() unless GC_parallel or available_markers_m1<=0.
* win32_threads.c (START_MARK_THREADS): Define macro (to call
GC_start_mark_threads() if PARALLEL_MARK).
* win32_threads.c (GC_CreateThread): Call START_MARK_THREADS() (right
before set_need_to_lock).
* win32_threads.c [!CYGWIN32 && !MSWINCE && !MSWIN_XBOX1 && !NO_CRT]
(GC_beginthreadex): Likewise.
* win32_threads.c [GC_PTHREADS] (GC_pthread_create): Likewise.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* darwin_stop_world.c [!GC_NO_THREADS_DISCOVERY
&& !DARWIN_DONT_PARSE_STACK] (GC_use_threads_discovery): Call GC_init()
instead of GC_init_parallel().
* pthread_support.c (pthread_create): Likewise.
* win32_threads.c [!GC_NO_THREADS_DISCOVERY]
(GC_use_threads_discovery): Likewise.
* win32_threads.c (GC_CreateThread): Likewise.
* win32_threads.c [!CYGWIN32 && !MSWINCE && !MSWIN_XBOX1 && !NO_CRT]
(GC_beginthreadex): Likewise.
* win32_threads.c [GC_PTHREADS] (GC_pthread_create): Likewise.
* include/private/gc_priv.h [THREADS] (GC_init, GC_init_parallel): Add
comment.
* misc.c (GC_init): Replace GC_PTHREADS||GC_WIN32_THREADS with THREADS.
* misc.c [THREADS] (GC_init): Call GC_init_parallel() even if no
parallel marker support or thread-local allocations; update comment.
* pthread_support.c (parallel_initialized): Remove.
* win32_threads.c (parallel_initialized): Likewise.
* pthread_support.c (GC_init_parallel): Update comment; do not use
parallel_initialized; do not call GC_init();
* win32_threads.c (GC_init_parallel): Likewise.
* pthread_support.c [THREAD_LOCAL_ALLOC] (GC_init_parallel): Declare
and use me local variable.
* pthread_support.c [THREAD_LOCAL_ALLOC] (GC_init_parallel): Remove
assertion that the GC lock is not hold; add assertion that
GC_is_initialized is set.
* win32_threads.c [THREAD_LOCAL_ALLOC] (GC_init_parallel): Likewise.
* pthread_support.c [THREAD_LOCAL_ALLOC] (GC_register_my_thread,
GC_start_rtn_prepare_thread): Remove redundant parentheses in
GC_init_thread_local() argument.
* win32_threads.c [THREAD_LOCAL_ALLOC] (GC_register_my_thread):
Likewise.
* win32_threads.c [!GC_NO_THREADS_DISCOVERY]
(GC_use_threads_discovery): Check GC_is_initialized value instead of
parallel_initialized one.
* win32_threads.c (GC_CreateThread): Likewise.
* win32_threads.c [!CYGWIN32 && !MSWINCE && !MSWIN_XBOX1 && !NO_CRT]
(GC_beginthreadex): Likewise.
* win32_threads.c [GC_PTHREADS] (GC_pthread_create): Likewise.
* win32_threads.c [!GC_PTHREADS && !GC_NO_THREADS_DISCOVERY]
(GC_DllMain): Likewise.
* win32_threads.c [THREAD_LOCAL_ALLOC] (GC_register_my_thread_inner):
Add comment.
* win32_threads.c [!GC_ALWAYS_MULTITHREADED && !PARALLEL_MARK
&& !GC_NO_THREADS_DISCOVERY] (GC_allow_register_threads): Do not set
parallel_initialized.
* win32_threads.c (GC_init_parallel): Call set_need_to_lock() after
GC_init_thread_local().
|
|
|
|
|
|
|
|
|
|
|
| |
* include/gc/gc.h (GC_use_threads_discovery): Refine comment (mention
GC_register_my_thread and GC_init).
* os_dep.c [MSWIN32 || MSWINCE] (GC_get_stack_base): Add comment about
the GC lock.
* win32_threads.c (GC_CreateThread): Add comment about GC_init_parallel
if GC_win32_dll_threads set by GC_use_threads_discovery().
* win32_threads.c [!GC_PTHREADS && !GC_NO_THREADS_DISCOVERY]
(GC_DllMain): Add more comments for DLL_THREAD_ATTACH case.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(fix of commit f1b257a66)
Also, enable GC_use_threads_discovery() on Windows even in case
of PARALLEL_MARK.
* tests/gctest.c [GC_WIN32_THREADS && !GC_PTHREADS && GC_DLL
&& !GC_NO_THREADS_DISCOVERY && !MSWINCE && !THREAD_LOCAL_ALLOC]
(WinMain): Call GC_use_threads_discovery() regardless of PARALLEL_MARK.
* win32_threads.c [!GC_PTHREADS && !GC_NO_THREADS_DISCOVERY
&& PARALLEL_MARK] (GC_DllMain): Do not abort if DLL_PROCESS_ATTACH or
DLL_THREAD_ATTACH (call GC_register_my_thread_inner instead).
|
|
|
|
|
|
|
|
|
|
| |
(fix of commits 3d7e4a8c6, 1175c7e62)
This is to match DLL_THREAD_ATTACH case if parallel_initialized is false.
* win32_threads.c [!GC_NO_THREADS_DISCOVERY && !GC_PTHREADS]
(GC_DllMain): Remove assertion that parallel_initialized is set (i.e.
for the case when GC_win32_dll_threads is set).
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
* pthread_support.c [GC_USE_DLOPEN_WRAP] (GC_init_real_syms): Assert
that GC_syms_initialized is set.
* pthread_support.c [HAVE_PTHREAD_SETNAME_NP_WITH_TID_AND_ARG
|| HAVE_PTHREAD_SETNAME_NP_WITH_TID] (set_marker_thread_name): Use
EXPECT().
* pthread_support.c (GC_new_thread, GC_delete_thread,
GC_register_altstack, GC_register_my_thread, pthread_create,
GC_lock): Likewise.
* pthread_support.c [!GC_NO_PTHREAD_SIGMASK] (pthread_sigmask):
Likewise.
* pthread_support.c [!SN_TARGET_ORBIS && !SN_TARGET_PSP2]
(pthread_join, pthread_detach): Likewise.
* pthread_support.c [!USE_SPIN_LOCK && !NO_PTHREAD_TRYLOCK
|| PARALLEL_MARK] (GC_generic_lock): Likewise.
* win32_threads.c (GC_new_thread, GC_get_max_thread_index,
GC_delete_thread, GC_register_my_thread, GC_CreateThread): Likewise.
* win32_threads.c [!GC_NO_THREADS_DISCOVERY]
(GC_register_my_thread_inner): Likewise.
* win32_threads.c [PARALLEL_MARK] (GC_start_mark_threads_inner,
GC_acquire_mark_lock, GC_release_mark_lock): Likewise.
* win32_threads.c [!CYGWIN32 && !MSWINCE && !MSWIN_XBOX1 && !NO_CRT]
(GC_beginthreadex): Likewise.
* win32_threads.c [GC_PTHREADS] (pthread_join, GC_pthread_create,
GC_pthread_detach): Likewise.
* pthread_support.c (GC_new_thread): Change !EXPECT(cond,TRUE) to
EXPECT(!cond,FALSE).
* win32_threads.c (GC_new_thread): Likewise.
* pthread_support.c (GC_register_my_thread): Remove duplicated code
related to GC_SUCCESS.
* win32_threads.c (GC_register_my_thread): Likewise.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
* CMakeLists.txt: Update year in copyright comment (2021 to 2022).
* alloc.c: Likewise.
* configure.ac: Likewise.
* dyn_load.c: Likewise.
* include/private/gc_priv.h: Likewise.
* include/private/gcconfig.h: Likewise.
* mallocx.c: Likewise.
* mark.c: Likewise.
* mark_rts.c: Likewise.
* misc.c: Likewise.
* os_dep.c: Likewise.
* pthread_support.c: Likewise.
* reclaim.c: Likewise.
* tests/gctest.c: Likewise.
* win32_threads.c: Likewise.
* LICENSE: Update year (2021 to 2022).
* allchblk.c: Add copyright line in header comment.
* darwin_stop_world.c: Likewise.
* dbg_mlc.c: Likewise.
* gcj_mlc.c: Likewise.
* headers.c: Likewise.
* include/gc/gc_inline.h: Likewise.
* include/gc/gc_mark.h: Likewise.
* include/private/gc_locks.h: Likewise.
* include/private/gc_pmark.h: Likewise.
* include/private/pthread_stop_world.h: Likewise.
* include/private/pthread_support.h: Likewise.
* mach_dep.c: Likewise.
* malloc.c: Likewise.
* thread_local_alloc.c: Likewise.
* typd_mlc.c: Likewise.
* finalize.c: Update year in copyright comment (2020 to 2022).
* include/gc/gc.h: Likewise.
* pthread_stop_world.c: Likewise.
|
|
|
|
|
|
|
|
|
| |
(fix of commit ab93e03de)
* pthread_support.c [GC_ASSERTIONS] (GC_allow_register_threads): Wrap
GC_lookup_thread() call into LOCK/UNLOCK.
* win32_threads.c [GC_ASSERTIONS] (GC_allow_register_threads): Wrap
GC_lookup_thread_inner() call into LOCK/UNLOCK.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
(refactoring)
Also, remove an unnecessary lock in GC pthread_create (of
pthread_support.c), and ensure that GC_thr_init() is called only once.
* alloc.c (GC_try_to_collect_inner, GC_collect_a_little_inner,
GC_stopped_mark, GC_collect_or_expand, GC_allocobj): Add assertion that
GC is initialized.
* finalize.c (GC_register_disappearing_link_inner,
GC_register_finalizer_inner): Likewise.
* mark.c (GC_clear_marks, GC_initiate_gc): Likewise.
* mark_rts.c (GC_push_roots): Likewise.
* alloc.c (GC_collect_a_little): Call GC_init if GC is not initialized.
* alloc.c (GC_expand_hp): Move part of comment to gc.h.
* include/gc/gc.h (GC_expand_hp): Reformat comment.
* darwin_stop_world.c (GC_push_all_stacks): Replace GC_init() call with
the assertion that GC_thr_initialized.
* pthread_stop_world.c (GC_push_all_stacks): Likewise.
* pthread_support.c (pthread_create): Likewise.
* darwin_stop_world.c (GC_stop_world): Add assertion that
GC_thr_initialized.
* pthread_stop_world.c (GC_stop_world): Likewise.
* win32_threads.c (GC_push_all_stacks): Likewise.
* finalize.c (GC_register_finalizer_inner): Add assertion (after LOCK)
that obj points to the base address of the object.
* include/private/pthread_support.h (GC_thr_initialized): Declare only
if GC_ASSERTIONS.
* pthread_support.c (GC_thr_initialized): Define only if GC_ASSERTIONS.
* win32_threads.c (GC_thr_initialized): Likewise.
* pthread_support.c (GC_thr_init): Add assertion that
GC_thr_initialized is not set on entry; set GC_thr_initialized only
if GC_ASSERTIONS.
* win32_threads.c (GC_thr_init): Likewise.
* pthread_support.c (pthread_create): Remove LOCK/UNLOCK around setup
of si.
* win32_threads.c (GC_stop_world): Replace ABORT (about
GC_thr_initialized) with the assertion.
* win32_threads.c (GC_CreateThread): Add assertion that
GC_thr_initialized after GC_init_parallel() call.
* win32_threads.c [!CYGWIN32 && !MSWINCE && !MSWIN_XBOX1 && !NO_CRT]
(GC_beginthreadex): Likewise.
* win32_threads.c [GC_PTHREADS] (GC_pthread_create): Likewise.
* win32_threads.c [!CYGWIN32 && !MSWINCE && !MSWIN_XBOX1 && !NO_CRT]
(GC_beginthreadex): Remove comment duplicating that in GC_CreateThread.
* win32_threads.c [GC_PTHREADS] (GC_pthread_create): Likewise.
|
|
|
|
|
|
|
|
|
|
| |
(fix of commit 0fbe44656)
TSan itself is not supported on Windows (native and Cygwin) yet.
* win32_threads.c [PARALLEL_MARK && (!GC_PTHREADS_PARAMARK
|| NUMERIC_THREAD_ID_UNIQUE)] (GC_acquire_mark_lock): Assertion about
GC_mark_lock_holder regardless of THREAD_SANITIZER.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
These are no-op definitions in case of the collector is built as
a single-threaded one. This is useful for single threaded clients
to be able to call these functions regardless of the collector is
multi-threaded or not.
* include/gc/gc.h [GC_THREADS] (GC_parallel): Reformat comment.
* include/gc/gc.h (GC_get_parallel, GC_set_markers_count): Declare
unconditionally.
* misc.c [!PARALLEL_MARK] (GC_set_markers_count): Define (as no-op).
* misc.c [!THREADS] (GC_get_parallel): Define (return 0).
* pthread_support.c (GC_set_markers_count): Define only if
PARALLEL_MARK; remove GC_ATTR_UNUSED.
* win32_threads.c (GC_set_markers_count): Likewise.
* tests/initfromthread.c (main): Call GC_get_suspend_signal() instead
of GC_get_parallel().
|