Looking at the freestore
At any given moment during the execution of a C++ program,
the freestore contains
all those objects which were newed at some time since the
start of the program, but
have not yet been deleted.
(This includes any objects newed during static initialization.)
For each of these objects in the freestore, fs
keeps track of the following information:
fs keeps track of objects created by regular new, array new,
nothrow new, and placement new - in other words, all of the
variations of new in Standard C++.
We also need ``names'' or ``handles'' by which we can refer to the objects
in the freestore.
These handles will come in useful when we make requests of
Notice that an object's memory address is a
poor handle by which to refer to it,
since (1) addresses are tedious to type,
and (2) different objects over the course
of program execution can have the same address.
Our solution is to give each freestore
object a small integer handle.
The first newed object is given the handle 0, and
successively newed objects are given handles continuing up the integers.
an object's handle distinguishes it from all other objects that are,
were, or ever
will be in the freestore.
The object's birthplace, that is, the source code line on which it was
The object's type.
The object's length (if it is an array).
The object's size (in bytes).
The object's memory address.
All the above symbolic
information can be displayed by calling the
library function fs_showall()
somewhere in the current context -- that is,
either from within the debugger, or
from within the program itself.
The information is printed on the standard error
is an example output:
#0: int, newed on line `t1.c`5
(size 4 at 0x24b84)
#2: int, newed on line `t2.c`32
(size 3 x 4 at 0x24bd8)
#5: T, newed on line `t1.c`14
(size 32 at 0x24c34)
Total of 7 objects newed since start,
3 still in freestore.
This is interpreted as follows:
In a large program, there will often be many objects in the freestore.
To aid in digesting the volume of information
that would be produced by a call to
fs_showall(), the user may set ``marks.''
A call to the function
lays down a ``mark'' at the current moment in time (that is,
not at the current source code location).
a mark has been laid down, a call to
will display the information for only
those objects which were newed since the mark.
To delete the mark, the user calls fs_unmark().
programmer may lay down as many marks as desired; fs_since() will
always display the information for only those objects
newed since the latest mark,
and fs_unmark() will only delete the latest mark.
The user can
see the current set of marks by calling the function fs_status().
output of this command will look something like the following:
The program has so far newed seven objects.
Of these seven, four
have been deleted, and three are still in the freestore.
The three in the freestore
are the zeroth, second, and fifth objects
that were newed since the start of the program.
Object #0 is a single integer.
It was newed on line 5 of file
Its size in bytes is 4, and it resides at memory location
Object #2 is an array of three integers.
It was newed on line 32
of file t2.c.
Its size in bytes is 12 (3 integers each of size 4),
and it resides at memory location 0x24bd8.
Object #5 is a single instance of class T.
It was newed on line
14 of file t1.c.
Its size in bytes is 32, and it resides at
memory location 0x24c34.
Marks after: 3, 12, 62
This means that there are currently three marks: the first mark was laid down
sometime after object #3 was newed,
but before object #4 was newed; the second mark
was laid down after object #12 but before object #13;
and the third mark after object
#62 but before #63.
fs_since() with this setting of marks will result in the information
for objects #63, #64, ..., being displayed.
If the user is interested in seeing all the objects newed after a particular
object #n (regardless of whether a mark was laid
down after #n), then a call to fs_sincen(n)
does the trick.
fs to the Rescue
© 2005 The SCO Group, Inc. All rights reserved.
SCO OpenServer Release 6.0.0 -- 02 June 2005