Tools.h++ Class Reference

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 that 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.
Persistence
None
Example
This example illustrates adding N nodes to a linked list. In this linked list, a "pointer" to the
next node is actually a handle.
#include <rw/vpage.h>
struct Node {
int key;
RWHandle next;
};
RWHandle head = 0;
void addNodes(RWVirtualPageHeap& heap, unsigned N) {
for (unsigned i=0; i<N; i++){
RWHandle h = heap.allocate();
Node* newNode = (Node*)heap.lock(h);
newNode->key = i;
newNode->next = head;
head = h;
heap.dirty(h);
heap.unlock(h);
}
}