Provided by: manpages-zh_1.5.1-2_all bug

NAME

       ckalloc,    memory,    ckfree,    Tcl_DisplayMemory,    Tcl_InitMemory,
       Tcl_ValidateAllMemory - 合法的内存分配接口

 SYNOPSIS
       memory info

       memory trace [on|off]

       memory validate [on|off]

       memory trace_on_at_malloc nnn

       memory break_on_malloc nnn

       memory display file

       #include <tcl.h>

       char *
       ckalloc (unsigned size)

       void
       ckfree (char *ptr)

       int
       Tcl_DumpActiveMemory (char *fileName);

       void
       Tcl_ValidateAllMemory (char *file,
                              int   line)

       void
       Tcl_InitMemory (interp)

ARGUMENTS

       Tcl_Interp *fileName uint size in

       char *ptr in Tcl_Interp *interp in A pointer to  the  Tcl  interpreter.
       char *file in The filename of the caller of Tcl_ValidateAllMemory.  int
       line in The line number of the caller of  Tcl_ValidateAllMemory.   char
       *fileName in File to display list of active memory.

 DESCRIPTION
   ckalloc
       This  macro  allocates  memory,  in the same manner as malloc, with the
       following differences: One, ckalloc  checks  the  value  returned  from
       malloc  (it  calls malloc for you) and panics if the allocation request
       fails.  Two, if enabled at compile time,  a  version  of  ckalloc  with
       special  memory  debugging  capabilities replaces the normal version of
       ckalloc, which aids in detecting memory overwrites and leaks  (repeated
       allocations not matched by corresponding frees).

       Parameters:
         o size - The size of the memory block to be allocated.

       Returns:
         A pointer to the allocated memory block.

   ckfree
       This  macro  frees  memory  allocated  by  ckalloc.  Like ckalloc, when
       memory debugging is  enabled,  ckfree  has  enhanced  capabilities  for
       detecting memory overwrites and leaks.

       It  is  very  important  that you use ckalloc when you need to allocate
       memory, and that you use ckfree to free it.  Should you use  malloc  to
       allocate  and  ckfree  to  free, spurious memory validation errors will
       occur when memory debugging is enabled.  Should you use  free  to  free
       memory  allocated  by ckalloc, memory corruption will occur when memory
       debugging is enabled.  Any memory that is to be become the property  of
       the  Tcl  interpreter,  such  as  result  space, must be allocated with
       ckalloc.  If it is absolutely necessary for an application to pass back
       malloced  memory  to Tcl, it will work only if Tcl is complied with the
       TCL_MEM_DEBUG flag turned off.  If you convert your application to  use
       this  facility, it will help you find memory over runs and lost memory.
       Note that memory allocated by a C  library  routine  requiring  freeing
       should  still  be  freed  with  free, since it calls malloc rather than
       ckalloc to do the allocation.

       Parmeters:
         o ptr - The address of a block to free, as returned by ckalloc.

   Tcl_DumpActiveMemory
       This function will output a list of all currently allocated  memory  to
       the  specified  file.   The following information is outputted for each
       allocated block of memory: starting  and  ending  addresses  (excluding
       guard zone), size, source file where ckalloc was called to allocate the
       block and line number in that file.  It is especially  useful  to  call
       Tcl_DumpActiveMemory after the Tcl interpreter has been deleted.

       Parameters:
         o fileName - The name of the file to output the memory list to.

   Tcl_ValidateAllMemory
       Forces  a  validation  of  the  guard  zones of all currently allocated
       blocks of memory.  Normally validation  of  a  block  occurs  when  its
       freed,  unless  full validation is enabled, in which case validation of
       all blocks occurs when ckalloc and ckfree are  called.   This  function
       forces the validation to occur at any point.

       Parameters:
         o  file  -  The file that this routine is being called from, normally
         __FILE__.
         o line - The line that this routine is being  called  from,  normally
         __LINE__.

ENABLING MEMORY DEBUGGING

       To  enable memory debugging, Tcl should be recompiled from scratch with
       TCL_MEM_DEBUG defined.  This will also compile in a non-stub version of
       Tcl_InitMemory to add the memory command to Tcl.

       TCL_MEM_DEBUG  must be either left defined for all modules or undefined
       for all modules that are going to be linked together.  If they are not,
       link  errors  will  occur, with either TclDbCkfree and Tcl_DbCkalloc or
       Tcl_Ckalloc and Tcl_Ckfree being undefined.

GUARD ZONES

       When memory debugging is enabled, whenever a call to ckalloc  is  made,
       slightly  more  memory  than  requested  is  allocated  so  the  memory
       debugging code can keep track of the allocated memory, and also  eight-
       byte  ``guard  zones'' are placed in front of and behind the space that
       will be returned to the caller.  (The size of the guard zone is defined
       by  the  C  #define  GUARD_SIZE  in baseline/src/ckalloc.c -- it can be
       extended if you suspect large  overwrite  problems,  at  some  cost  in
       performance.)   A known pattern is written into the guard zones and, on
       a call to ckfree, the guard zones of the space being freed are  checked
       to  see  if either zone has been modified in any way.  If one has been,
       the guard bytes and their new contents  are  identified,  and  a  ``low
       guard failed'' or ``high guard failed'' message is issued.  The ``guard
       failed'' message includes the address of the memory packet and the file
       name  and  line number of the code that called ckfree.  This allows you
       to detect the common sorts of one-off problems, where not enough  space
       was allocated to contain the data written, for example.

THE MEMORY COMMAND

       memory options
              The  Tcl memory command gives the Tcl developer control of Tcl's
              memory debugging capabilities.  The memory command  has  several
              suboptions,  which  are  described  below.  It is only available
              when Tcl has been compiled with memory debugging enabled.

       memory info
              生成一个报告,包含自从                                       Tcl
              启动以来分配和释放的(内存)总数,当前分配的包(未遇到相应的到
              ckfree                    的调用的到                     ckalloc
              的调用的当前数目)的数目,当前分配的字节数,和已分配的包和字节的最大的数目。

       memory trace [on|off]
              使内存跟踪开启或关闭。在开启内存跟踪的时候,对           ckalloc
              的每次调用都导致向          stderr    写一行跟踪信息,其组成有字
              ckalloc,随后是返回的地址,分配的内存总数,和进行分配的        C
              文件名和代码的行数。例如:...

                 ckalloc 40e478 98 tclProc.c 1406

              Calls  to  ckfree are traced in the same manner, except that the
              word ckalloc is replaced by the word ckfree.

       memory validate [on|off]
              使内存生效(validation)开启或关闭。在开启内存生效的时候,在对ckallocckfree          的每次调用上,检查用         ckalloc
              分配的每块现存的内存的守卫区(guard
              zone)。这有很大的性能影响而只在强烈怀疑有覆写(overwrite)问题的时候才使用。开启内存生效的益处是在覆写发生之后第一次调用
              ckallocckfree
              的时候就能检测到守卫区覆写,而不是在释放有覆写守卫区的内存的时候,释放可能在内存覆写发生之后才发生。

       memory trace_on_at_malloc nnn
              在进行了 count 数目 ckalloc 之后启用内存跟踪。例如,如果你键入了
              memory   trace_on_at_malloc   100,在第     100  次调用  ckalloc
              之后,将对所有分配和释放的内存显示内存跟踪信息。因为在一个问题发生之前可能有许多内存活动,如果你能在问题出现(
              sets
              in)之前标识出一定数目的分配,决定(judicious)使用这个选项可以减轻跟踪导致的速度变慢(和生成的跟踪信息总数)。在发生一个守卫区错误时,输出自从
              Tcl  启动以来发生的内存分配的当前数目。

       memory break_on_malloc nnn
              在进行了             count             数目的            ckalloc
              分配之后,输出一个(中断)消息,表示它现在想进入 C  调试器。   Tcl
              将向自身发出一个   SIGINT   信号。如果你在一个  C   调试器下运行
              Tcl,它将接着进入调试器命令模式。

       memory display file
              向指定文件写当前所有分配的内存的一个列表。

DEBUGGING DIFFICULT MEMORY CORRUPTION PROBLEMS

       Normally, Tcl compiled with memory debugging enabled will make it  easy
       to isolate a corruption problem.  Turning on memory validation with the
       memory command can help isolate difficult problems.  If you suspect (or
       know)  that corruption is occurring before the Tcl interpreter comes up
       far enough for you to issue commands, you can set MEM_VALIDATE  define,
       recompile  tclCkalloc.c  and  rebuild  Tcl.   This  will  enable memory
       validation  from  the  first  call  to  ckalloc,  again,  at  a   large
       performance impact.

       If you are desperate and validating memory on every call to ckalloc and
       ckfree isn't enough,  you  can  explicitly  call  Tcl_ValidateAllMemory
       directly at any point.  It takes a char * and an int which are normally
       the filename and line number of the caller, but they  can  actually  be
       anything  you  want.   Remember  to remove the calls after you find the
       problem.

 KEYWORDS
       ckalloc, ckfree, free, memory, malloc

[[2001/09/28

 Linux man:
       http://cmpp.linuxforum.net