Tools.h++ Manual

104011 Tandem Computers Incorporated 21-193
21
RWVirtualPageHeap
Synopsis #include <rw/vpage.h>
(Abstract base class)
Description This is an abstract base class representing an abstract page heap of fixed sized
pages. The following describes the model by which specializing classes of this
class are expected to work.
You allocate a page off the abstract heap by calling member function
allocate() which will return a memory "handle", an object of type
RWHandle . This handle logically represents the page.
In order to use the page it must first be "locked" by calling member function
lock() with the handle as an argument. It is the job of the specializing class
of RWVirtualPageHeap to make whatever arrangements are necessary to
swap in the page associated with the handle and bring it into physical memory.
The actual swapping medium could be disk, expanded or extended memory, or
a machine someplace on a network. Upon return, lock() returns a pointer to
the page, now residing in memory.
Once a page is in memory, you are free to do anything you want with it
although if you change the contents, you must call member function dirty()
before unlocking the page.
Locked pages use up memory. In fact, some specializing classes may have only
a fixed number of buffers in which to do their swapping. If you are not using
the page, you should call unlock() . After calling unlock() the original
address returned by lock() is no longer valid—to use the page again, it must
be locked again with lock() .
When you are completely done with the page then call deallocate() to
return it to the abstract heap.
In practice, managing this locking and unlocking and the inevitable type casts
can be difficult. It is usually easier to design a class than can work with an
abstract heap to bring things in and out of memory automatically. Indeed, this
is what has been done with class RWTValVirtualArray<T> , which represents
a virtual array of elements of type T. Elements are automatically swapped in
as necessary as they are addressed.