Robin.

Well, Steve, I do appreciate your greater experience in worming out the
secrets of where resources go to in Poplog. But what is hidden in procedures
(apart from manifest things like frozvals, updaters)?  -datasize-  presumably
gives the amount of code. Problems seem to be:

(i)   Getting hold of file-lexicals.
(ii)  Internal structure of procedures.
(iii) Devices are opaque
(iv)  Processes and most of the call-stack are opaque.
(v)   XptDescriptors are opaque.
(vi)  External pointers are opaque.

Whether the limited tool below is of any use I don't know. It would help me,
since I memoise functions and forget about them... But would not help
X-related leaks.
-----------------------------------------------------------------------------
       Example of use

: profile_store(200);
vedupperfile  720
emacsescapetable  817
vedbufferlist  76441
sysstring  512
vveddump  5184

----------------------------------------------------------------------------
/*
This runs on Poplog 14.0 without datasize.

Call profile_store(n) to obtain a listing of words whose dependent store is
larger than n words.
*/
section profile => profile_store;

vars procedure(
    marked = newassoc([]),
    profile_word,
    size_profile,
    is_profilable
);

define profile_store(n);
  lvars n;
  newassoc([]) -> marked;
  appdic(profile_word(%n%));
enddefine;

define profile_word(W,n); lvars n,W;
  unless W == "marked_profile" or not(isdefined(W))
  then lvars V = valof(W), n1 = size_profile(V);
    if  n1>n  then pr(W); sp(2); npr(n1);
    endif;
  endunless
enddefine;

define size_profile(V);
  lvars V; ;;; V -> VV;
  if iscompound(V) and isinheap(V) and not(marked(V))
    and is_profilable(V)
  then
      true -> marked(V);
      lvars n = datalength(V);
      appdata(V, procedure(d); size_profile(d)+n->n endprocedure);
       n
  else 0
  endif;
enddefine;

define is_profilable(V); lvars V;
   not(
     isprocedure(V) or isdevice(V) or isprocess(V)
    or isexternal_ptr(V) or isXptDescriptor(V)
  )
enddefine;

endsection

Robin

popgctrace -> BOOL or INT                                     [variable]
BOOL or INT -> popgctrace
        If this variable (default value <false>) is true then a  message
        is output after each garbage collection, giving the GC time  and
        details of memory allocation (the characters of the message  are
        output through -cucharout-).

        The first line of the message has the form

            GC-<code>(X) <t>  MEM: u <u> + f <f> + s <s> = <m>

        where <code> is a 4-letter code indicating why the GC  happened,
        and <t> is the time for the garbage collection in seconds. X  is
        a letter indicating which garbage collection algorithm was  used
        (C = copying, N = non-copying).

        <code> is one of the following:

            auto    The combined area for relocatable structures and the
                    user stack was full.

            fixd    The area for fixed-address structures was full.

            ftbl    The internal table  of open  files/devices was  full
                    when trying to open a  device. (A GC can free  space
                    in  this  table  by  closing  and  removing  garbage
                    devices.)

            fopn    The operating-system imposed limit on the number  of
                    open devices  was  reached  when  trying  to  open a
                    device. (By closing garbage  devices, a GC can  make
                    more available.)

            plog    The  combined  area   for  the   Prolog  trail   and
                    continuation stack was full.

            save    GC done by -syssave-.

            lock    GC done by -sys_lock_system-.

            user    Direct call of -sysgarbage- from a user program.

        The MEM figures refer  to totals for all  heap segments: <u>  is
        the number of words used by structures, <f> the number free, <s>
        the number taken by  the user stack, and  <m> the total. If  the
        heap is  locked  with  -sys_lock_heap- then  an  additional  <l>
        figure precedes <u>, i.e.

            GC-<code>(X) <t>  MEM: l <l> + u <u> + f <f> + s <s> = <m>

        where <l> is the total number of words in the locked part of the
        heap (note this includes both used and unused space).

        If -popgctrace- has any non-false  value other than an  integer,
        only  the  first  line  is  output.  Additional  information  is
        obtained by  giving  it  an integer  value,  whose  bits  select
        further message lines as follows:

            Bit     Meaning
            ---     -------
             0      Same as setting  both bits 2  and 3 (for  upward
                    compatibility  in   assigning  1   to  get   the
                    callstack and Prolog information).

             1      Fixed-address structures; prints

                      FIXED: u <u> + fb <fb> + f <f> = <m>

                    where  <u>  is  the  number  of  words  used  by
                    structures,  <fb>   the   number  used   up   in
                    (discontiguous) free blocks,  <f> the number  of
                    (contiguous) free,  and  <m>  the  total.  These
                    values are  included in  the first-line  totals,
                    <fb> and <f> being subsumed together under total
                    words free.
                        (Note   that    space   for    fixed-address
                    structures is  allocated  from  free  blocks  if
                    possible, but because  of fragmentation a  given
                    figure for <fb> doesn't imply that that  much is
                    actually usable in any context.)

             2      Callstack; prints

                      CALLSTACK: <c>

                    where  <c>  is  the  number  of  words  used  by
                    procedure-call stack frames.

             3      Prolog store area; prints

                      PROLOG: trail <t> + free <f> + contn <c> = <m>

                    where <t> is  the number  of words  used by  the
                    trail, <f> the number free, <c> the number  used
                    by the continuation stack, and <m> the total.