report_size

        my $record = report_size( $reference, $options ) . "\n";
        print $record;

Walks the given reference recursively and returns text tree describing the size of each element. $options is a hash, containing the following optional keys:

        names     ref to HASH mapping the types to names
                  This should map S_Scalar to something like "Scalar" etc
        indent    string to indent different levels with, default is '  '
        left      indent all text with this at the left side, default is ''
        inner     indent inner text with this at the left side, default is '  '
        total     if true, a total size will be printed as last line
        bytes     name of the size unit, defaults to 'bytes'
        head      header string, default 'Size report for'
                  Set to '' to supress header completely        
        overhead  Format string for the overhead, first size in bytes, then
                  the bytes string (see above) and then the percentage.
                  The default is:
                  " (overhead: %i%s, %0.2f%%)"
        addr      if true, for each element the memory address will be output
        class     if true, show the class each element was blessed in
        terse     if true, details for elements will be supressed, e.g. you
                  will only get the header, total and summary (if requested)
        summary   if true, print a table summing up the memory details on a
                  per-class basis
        doubles   If true, hash keys and array elemts that point to the same
                  thing in memory will be reported. Default is off, since it
                  saves memory. Note that you will usually only get double
                  entries in hashes and array by using Array::RefElem's methods
                  or similiar hacks/tricks.

entries_per_element

        my $entries = entries_per_element();

Returns the number of entries per element that track_size() will generate.

track_sizes

        $elements = track_sizes( $reference, $level);

Walk the given scalar or reference recursively and returns a ref to an array, containing entries_per_element entries for each element in the structure pointed to by $reference. $reference can also be a plain scalar.

The entries for each element are currently:

        level     the indent level
        type      the type of the element, S_SCALAR, S_HASH, S_ARRAY etc
                  if (type & SF_KEY) != 0, the element is a member of a hash
        size      size in bytes of the element
        overhead  if the element is an ARRAY or HASH, contains the overhead
                  in bytes (size - sum(size of all elements)).
        name      if type & SF_KEY != 0, this contains the name of the hash key
        addr      memory address of the element
        class     classname that the element was blessed into, or ''

track_size

        @elements = track_size( $reference, $level);

Works just like track_sizes, but for backward compatibility reasons returns an array with the results.

hide_tracks

        hide_tracks();

Releases the memory consumed by a call to track_size or track_sizes.

type

        $type_number = type($type_name);

Maps a type name (like 'SCALAR') to a type number (lilke S_SCALAR).

element_type

        $type_name = element_type($type_nr);

Maps a type number (like S_SCALAR) to a type name (lilke 'SCALAR').