Maintenance script: Repair batch-0002 pages from live compare

2026-03-27T00:16:03Z

Repair batch-0002 pages from live compare

imported>Unknown at 05:23, 7 February 2021

2021-02-07T05:23:18Z

New page

[http://www.hpl.hp.com/personal/Hans_Boehm/gc/ 홈페이지]

= 인스톨 =
* README.QUICK 파일에 기본적인 설명이 있다. doc/README.* 에 플렛폼별 자세한 설명이 있다.

* 유닉스나 리눅스에서는 "./configure --prefix=<dir>; make; make check; make install" 으로 인스톨 할수 있다.
** C++ 인터 페이스를 추가 하기 위해서는 "make c++" 을 하여야 한다.

* GNU-win32 에서는 기본으로 있는 Makefile 을 사용하면된다.
/! 시스템에 따라 Makefile 내용 중 CC=cc 를 CC=gcc 로 수정하여야 한다.
** C++ 인터 페이스를 추가 하기 위해서는 "make c++" 을 하여야 한다.

* MS 개발 툴을 사용한다면 NT_MAKEFILE 을 MAKEFILE 로 이름을 바꾸어 사용한다.
** win32 쓰레드를 지원하려면 NT_THREADS_MAKEFILE 을 사용한다. (gc.mak 도 같은 파일 이다.)
** 예) nmake /F ".gc.mak" CFG="gctest - Win32 Release"

* 볼랜드 개발 툴을 사용한다면 BCC_MAKEFILE 을 사용한다.

== 내가 사용한 인스톨 ==
* WinXP, MinGW, Msys
** Makefile 수정 내용.
** CC=cc 를 CC=gcc 로 수정.
** -DGC_OPERATOR_NEW_ARRAY -DJAVA_FINALIZATION 을 CFLAGS 에 추가.

** 빌드
** make c++

== 이슈 ==
* Windows NT 나 Windows 2000 에서 문제가 발생한다면 -DUSE_GLOBAL_ALLOC 나 -DUSE_MUNMAP 옵션을 사용하여 컴파일 한다.
* C++ 에서 사용하려면 -DGC_OPERATOR_NEW_ARRAY 를 추가하여 컴파일 하는 것이 좋다.
class A: public gc {...};
A* a1 = new A[ 10 ]; // collectable or uncollectable? (컴파일러마다 다른 결과가 나온다.)
A* a2 = new (GC) A[ 10 ]; // collectable

== 옵션 ==
# -DSILENT disables statistics printing, and improves performance.
# -DFIND_LEAK causes GC_find_leak to be initially set.
# This causes the collector to assume that all inaccessible
# objects should have been explicitly deallocated, and reports exceptions.
# Finalization and the test program are not usable in this mode.
# -DGC_SOLARIS_THREADS enables support for Solaris (thr_) threads.
# (Clients should also define GC_SOLARIS_THREADS and then include
# gc.h before performing thr_ or dl* or GC_ operations.)
# Must also define -D_REENTRANT.
# -DGC_SOLARIS_PTHREADS enables support for Solaris pthreads.
# (Internally this define GC_SOLARIS_THREADS as well.)
# -DGC_IRIX_THREADS enables support for Irix pthreads. See README.irix.
# -DGC_HPUX_THREADS enables support for HP/UX 11 pthreads.
# Also requires -D_REENTRANT or -D_POSIX_C_SOURCE=199506L. See README.hp.
# -DGC_LINUX_THREADS enables support for Xavier Leroy's Linux threads.
# see README.linux. -D_REENTRANT may also be required.
# -DGC_OSF1_THREADS enables support for Tru64 pthreads. Untested.
# -DGC_FREEBSD_THREADS enables support for FreeBSD pthreads. Untested.
# Appeared to run into some underlying thread problems.
# -DGC_DGUX386_THREADS enables support for DB/UX on I386 threads.
# See README.DGUX386.
# -DALL_INTERIOR_POINTERS allows all pointers to the interior
# of objects to be recognized. (See gc_priv.h for consequences.)
# Alternatively, GC_all_interior_pointers can be set at process
# initialization time.
# -DSMALL_CONFIG tries to tune the collector for small heap sizes,
# usually causing it to use less space in such situations.
# Incremental collection no longer works in this case.
# -DLARGE_CONFIG tunes the collector for unusually large heaps.
# Necessary for heaps larger than about 500 MB on most machines.
# Recommended for heaps larger than about 64 MB.
# -DDONT_ADD_BYTE_AT_END is meaningful only with -DALL_INTERIOR_POINTERS or
# GC_all_interior_pointers = 1. Normally -DALL_INTERIOR_POINTERS
# causes all objects to be padded so that pointers just past the end of
# an object can be recognized. This can be expensive. (The padding
# is normally more than one byte due to alignment constraints.)
# -DDONT_ADD_BYTE_AT_END disables the padding.
# -DNO_SIGNALS does not disable signals during critical parts of
# the GC process. This is no less correct than many malloc
# implementations, and it sometimes has a significant performance
# impact. However, it is dangerous for many not-quite-ANSI C
# programs that call things like printf in asynchronous signal handlers.
# This is on by default. Turning it off has not been extensively tested with
# compilers that reorder stores. It should have been.
# -DNO_EXECUTE_PERMISSION may cause some or all of the heap to not
# have execute permission, i.e. it may be impossible to execute
# code from the heap. Currently this only affects the incremental
# collector on UNIX machines. It may greatly improve its performance,
# since this may avoid some expensive cache synchronization.
# -DGC_NO_OPERATOR_NEW_ARRAY declares that the C++ compiler does not support
# the new syntax "operator new[]" for allocating and deleting arrays.
# See gc_cpp.h for details. No effect on the C part of the collector.
# This is defined implicitly in a few environments. Must also be defined
# by clients that use gc_cpp.h.
# -DREDIRECT_MALLOC=X causes malloc to be defined as alias for X.
# Unless the following macros are defined, realloc is also redirected
# to GC_realloc, and free is redirected to GC_free.
# Calloc and strdup are redefined in terms of the new malloc. X should
# be either GC_malloc or GC_malloc_uncollectable, or
# GC_debug_malloc_replacement. (The latter invokes GC_debug_malloc
# with dummy source location information, but still results in
# properly remembered call stacks on Linux/X86 and Solaris/SPARC.
# It requires that the following two macros also be used.)
# The former is occasionally useful for working around leaks in code
# you don't want to (or can't) look at. It may not work for
# existing code, but it often does. Neither works on all platforms,
# since some ports use malloc or calloc to obtain system memory.
# (Probably works for UNIX, and win32.) If you build with DBG_HDRS_ALL,
# you should only use GC_debug_malloc_replacement as a malloc
# replacement.
# -DREDIRECT_REALLOC=X causes GC_realloc to be redirected to X.
# The canonical use is -DREDIRECT_REALLOC=GC_debug_realloc_replacement,
# together with -DREDIRECT_MALLOC=GC_debug_malloc_replacement to
# generate leak reports with call stacks for both malloc and realloc.
# This also requires the following:
# -DREDIRECT_FREE=X causes free to be redirected to X. The
# canonical use is -DREDIRECT_FREE=GC_debug_free.
# -DIGNORE_FREE turns calls to free into a noop. Only useful with
# -DREDIRECT_MALLOC.
# -DNO_DEBUGGING removes GC_dump and the debugging routines it calls.
# Reduces code size slightly at the expense of debuggability.
# -DJAVA_FINALIZATION makes it somewhat safer to finalize objects out of
# order by specifying a nonstandard finalization mark procedure (see
# finalize.c). Objects reachable from finalizable objects will be marked
# in a sepearte postpass, and hence their memory won't be reclaimed.
# Not recommended unless you are implementing a language that specifies
# these semantics. Since 5.0, determines only only the initial value
# of GC_java_finalization variable.
# -DFINALIZE_ON_DEMAND causes finalizers to be run only in response
# to explicit GC_invoke_finalizers() calls.
# In 5.0 this became runtime adjustable, and this only determines the
# initial value of GC_finalize_on_demand.
# -DATOMIC_UNCOLLECTABLE includes code for GC_malloc_atomic_uncollectable.
# This is useful if either the vendor malloc implementation is poor,
# or if REDIRECT_MALLOC is used.
# -DHBLKSIZE=ddd, where ddd is a power of 2 between 512 and 16384, explicitly
# sets the heap block size. Each heap block is devoted to a single size and
# kind of object. For the incremental collector it makes sense to match
# the most likely page size. Otherwise large values result in more
# fragmentation, but generally better performance for large heaps.
# -DUSE_MMAP use MMAP instead of sbrk to get new memory.
# Works for Solaris and Irix.
# -DUSE_MUNMAP causes memory to be returned to the OS under the right
# circumstances. This currently disables VM-based incremental collection.
# This is currently experimental, and works only under some Unix,
# Linux and Windows versions.
# -DMMAP_STACKS (for Solaris threads) Use mmap from /dev/zero rather than
# GC_scratch_alloc() to get stack memory.
# -DPRINT_BLACK_LIST Whenever a black list entry is added, i.e. whenever
# the garbage collector detects a value that looks almost, but not quite,
# like a pointer, print both the address containing the value, and the
# value of the near-bogus-pointer. Can be used to identifiy regions of
# memory that are likely to contribute misidentified pointers.
# -DKEEP_BACK_PTRS Add code to save back pointers in debugging headers
# for objects allocated with the debugging allocator. If all objects
# through GC_MALLOC with GC_DEBUG defined, this allows the client
# to determine how particular or randomly chosen objects are reachable
# for debugging/profiling purposes. The gc_backptr.h interface is
# implemented only if this is defined.
# -DGC_ASSERTIONS Enable some internal GC assertion checking. Currently
# this facility is only used in a few places. It is intended primarily
# for debugging of the garbage collector itself, but could also
# -DDBG_HDRS_ALL Make sure that all objects have debug headers. Increases
# the reliability (from 99.9999% to 100%) of some of the debugging
# code (especially KEEP_BACK_PTRS). Makes -DSHORT_DBG_HDRS possible.
# Assumes that all client allocation is done through debugging
# allocators.
# -DSHORT_DBG_HDRS Assume that all objects have debug headers. Shorten
# the headers to minimize object size, at the expense of checking for
# writes past the end of an object. This is intended for environments
# in which most client code is written in a "safe" language, such as
# Scheme or Java. Assumes that all client allocation is done using
# the GC_debug_ functions, or through the macros that expand to these,
# or by redirecting malloc to GC_debug_malloc_replacement.
# (Also eliminates the field for the requested object size.)
# occasionally be useful for debugging of client code. Slows down the
# collector somewhat, but not drastically.
# -DSAVE_CALL_COUNT=<n> Set the number of call frames saved with objects
# allocated through the debugging interface. Affects the amount of
# information generated in leak reports. Only matters on platforms
# on which we can quickly generate call stacks, currently Linux/(X86 & SPARC)
# and Solaris/SPARC and platforms that provide execinfo.h.
# Default is zero. On X86, client
# code should NOT be compiled with -fomit-frame-pointer.
# -DSAVE_CALL_NARGS=<n> Set the number of functions arguments to be
# saved with each call frame. Default is zero. Ignored if we
# don't know how to retrieve arguments on the platform.
# -DCHECKSUMS reports on erroneously clear dirty bits, and unexpectedly
# altered stubborn objects, at substantial performance cost.
# Use only for debugging of the incremental collector.
# -DGC_GCJ_SUPPORT includes support for gcj (and possibly other systems
# that include a pointer to a type descriptor in each allocated object).
# Building this way requires an ANSI C compiler.
# -DUSE_I686_PREFETCH causes the collector to issue Pentium III style
# prefetch instructions. No effect except on X86 Linux platforms.
# Assumes a very recent gcc-compatible compiler and assembler.
# (Gas prefetcht0 support was added around May 1999.)
# Empirically the code appears to still run correctly on Pentium II
# processors, though with no performance benefit. May not run on other
# X86 processors? In some cases this improves performance by
# 15% or so.
# -DUSE_3DNOW_PREFETCH causes the collector to issue AMD 3DNow style
# prefetch instructions. Same restrictions as USE_I686_PREFETCH.
# Minimally tested. Didn't appear to be an obvious win on a K6-2/500.
# -DGC_USE_LD_WRAP in combination with the old flags listed in README.linux
# causes the collector some system and pthread calls in a more transparent
# fashion than the usual macro-based approach. Requires GNU ld, and
# currently probably works only with Linux.
# -DTHREAD_LOCAL_ALLOC defines GC_local_malloc(), GC_local_malloc_atomic()
# and GC_local_gcj_malloc(). Needed for gc_gcj.h interface. These allocate
# in a way that usually does not involve acquisition of a global lock.
# Currently requires -DGC_LINUX_THREADS, but should be easy to port to
# other pthreads environments. Recommended for multiprocessors.
# -DPARALLEL_MARK allows the marker to run in multiple threads. Recommended
# for multiprocessors. Currently requires Linux on X86 or IA64, though
# support for other Posix platforms should be fairly easy to add,
# if the thread implementation is otherwise supported.
# -DNO_GETENV prevents the collector from looking at environment variables.
# These may otherwise alter its configuration, or turn off GC altogether.
# I don't know of a reason to disable this, except possibly if the
# resulting process runs as a privileged user?
# -DUSE_GLOBAL_ALLOC. Win32 only. Use GlobalAlloc instead of
# VirtualAlloc to allocate the heap. May be needed to work around
# a Windows NT/2000 issue. Incompatible with USE_MUNMAP.
# See README.win32 for details.
# -DMAKE_BACK_GRAPH. Enable GC_PRINT_BACK_HEIGHT environment variable.
# See README.environment for details. Experimental. Limited platform
# support. Implies DBG_HDRS_ALL. All allocation should be done using
# the debug interface.
# -DSTUBBORN_ALLOC allows allocation of "hard to change" objects, and thus
# makes incremental collection easier. Was enabled by default until 6.0.
# Rarely used, to my knowledge.
# -DHANDLE_FORK attempts to make GC_malloc() work in a child process fork()ed
# from a multithreaded parent. Currently only supported by linux_threads.c.
# (Similar code should work on Solaris or Irix, but it hasn't been tried.)

= 사용법 =
== 인터페이스 ==
* [http://www.hpl.hp.com/personal/Hans_Boehm/gc/gcinterface.html 설명]

----
contributor [[lostship]]
----
[[도구분류]]

← Older revision		Revision as of 00:16, 27 March 2026
Line 4:		Line 4:
	* README.QUICK 파일에 기본적인 설명이 있다. doc/README.* 에 플렛폼별 자세한 설명이 있다.		* README.QUICK 파일에 기본적인 설명이 있다. doc/README.* 에 플렛폼별 자세한 설명이 있다.

	* 유닉스나 리눅스에서는 "./configure --prefix=~~<~~dir~~>~~; make; make check; make install" 으로 인스톨 할수 있다.		* 유닉스나 리눅스에서는 "./configure --prefix=<dir>; make; make check; make install" 으로 인스톨 할수 있다.
	** C++ 인터 페이스를 추가 하기 위해서는 "make c++" 을 하여야 한다.		** C++ 인터 페이스를 추가 하기 위해서는 "make c++" 을 하여야 한다.

Line 30:		Line 30:
	* C++ 에서 사용하려면 -DGC_OPERATOR_NEW_ARRAY 를 추가하여 컴파일 하는 것이 좋다.		* C++ 에서 사용하려면 -DGC_OPERATOR_NEW_ARRAY 를 추가하여 컴파일 하는 것이 좋다.
	class A: public gc {...};		class A: public gc {...};
	A* a1 = new A[ 10 ]; // collectable or uncollectable? (컴파일러마다 다른 결과가 나온다.)		A* a1 = new A[ 10 ]; // collectable or uncollectable? (컴파일러마다 다른 결과가 나온다.)
	A* a2 = new (GC) A[ 10 ]; // collectable		A* a2 = new (GC) A[ 10 ]; // collectable


Line 85:		Line 85:
	# since this may avoid some expensive cache synchronization.		# since this may avoid some expensive cache synchronization.
	# -DGC_NO_OPERATOR_NEW_ARRAY declares that the C++ compiler does not support		# -DGC_NO_OPERATOR_NEW_ARRAY declares that the C++ compiler does not support
	# the new syntax "operator new[]" for allocating and deleting arrays.		# the new syntax "operator new[]" for allocating and deleting arrays.
	# See gc_cpp.h for details. No effect on the C part of the collector.		# See gc_cpp.h for details. No effect on the C part of the collector.
	# This is defined implicitly in a few environments. Must also be defined		# This is defined implicitly in a few environments. Must also be defined
Line 239:		Line 239:
	----		----
	[[도구분류]]		[[도구분류]]

Garbage collector for C and C++ - Revision history

Maintenance script: Repair batch-0002 pages from live compare

imported>Unknown at 05:23, 7 February 2021