[http://www.hpl.hp.com/personal/Hans_Boehm/gc/ 홈페이지] = 인스톨 = * README.QUICK 파일에 기본적인 설명이 있다. doc/README.* 에 플렛폼별 자세한 설명이 있다. * 유닉스나 리눅스에서는 "./configure --prefix=; 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 를 추가하여 컴파일 하는 것이 좋다. {{{~cpp class A: public gc {...}; A* a1 = new A[ 10 ]; // collectable or uncollectable? (컴파일러마다 다른 결과가 나온다.) A* a2 = new (GC) A[ 10 ]; // collectable }}} == 옵션 == {{{~cpp # -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= 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= 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"] ---- ["도구분류"]