C++Talk.NET

Glen Low · Guest

Dear all,

I've been mulling over several things lately (no, not including the
seasonal mulled wine...), and I've got a proposal that I'd like your
comments on.

The big picture:

Dynamically allocated objects are typically strewn about the heap,
even though they are logically related. Pointers to these objects are
necessarily absolute.

This means:

1. Poor locality of reference, which stresses out today's CPU
architectures where the CPU and any cache is much faster than main
memory.

2. Serialization has to be done piecemeal, whereas if the objects were
all in one block, the block itself could be written out.

3. Transporting the objects (generalization of serialization) is
cumbersome, since the pointers are absolute. You can't easily move the
entire block to another spot in memory or over the network, since the
absolute pointers would have to be fixed up.

4. Heap allocation algorithms have to be fairly sophisicated and still
manage to be slow.

5. On some operating systems like Mach (Mac OS X) you can use VM
remapping to make COW copies of blocks of memory; however the absolute
pointers within force you to fix up the block after the copy, negating
the benefits of COW.

A proposal with two edges:

1. Define a (placement) operator new and operator delete, possibly
restricted to a class hierarchy, that allocates sequential memory from
a (heap allocated) block. When the block's memory is exhausted, the
entire block is copied over into a new block of 1.5x size, much like
the vector reallocation algorithm. Deletes are effectively ignored.

2. Define a new ptr template, to be called offset_ptr or relative_ptr,
which instead of storing an absolute address of memory, stores a
ptrdiff_t offset. When dereferenced or converted into a regular
pointer, it just takes it's own "this" pointer and adds the offset;
assignments and copy constructors have to be careful to recalculate
the offset appropriately. The semantics would be similar to regular
pointers or boost counted pointers (but w/o the reference counting).

Thus a program with some discipline, could easily create a sequential
block of memory with semantic content and with relative pointers. It's
not unprecedented for code, since some code loaders use some sort of
PC-relative mode instead of address fixups.

Any comments? Anybody tried something similar before in C++?

Cheers,
Glen Low, Pixelglow Software
www.pixelglow.com

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Glen Low · Guest