Smaller pointers... possible? (without a lower spec system)

Question

In this 2010 paper^[1] on raycasting sparse voxel octrees (SVOs) (apologies; the paper takes a while to load), section 3 indicates an interesting memory setup to save space on voxel data, which almost invariably is very large.

They specify a 15-bit relative pointer, with a 1-bit flag to specify whether a far pointer is needed (if the volume data is too large, the flag is set, and the 15-bit pointer is considered to point to a secondary, far pointer).

What's being done to achieve this? Is this something to do with CUDA / the GPU? Is it done through a custom allocator of some sort, in C++ code?

How would this be done in C++, if at all?

^[1]_{Efficient Sparse Voxel Octrees: Samuli Laine, Tero Karras; NVIDIA Research}

Answer 1

Well, you can always manually store the memory in an array and use integer indexes as "pointers".

Answer 2

In C/C++ you can interpret numbers as pointers in any way that you like - but it means that you wouldn't be able to simply dereference / add / subtract and do other normal pointer things . Instead you would have to use functions converting to a 'true' pointer to do these sorts of operations.

In C++ you could wrap all this up very neatly inside a class that presents a pointer-like interface by implementing operator*, opeartor->, and the arithmetic operators.

Just based on glancing at figure 2, this is what an implementation of the proposed pointers might look like (note that if you actually do this, then you're going to want to make sure the class isn't padded out to 32 or 64 bits anyway, and that they are allocated on 2-byte boundaries - there are normally compiler-specific directives to control this.)

class SmallChildPointer{
    public:
        SmallChildPointer(Child* bigChildPointer)
            : value(){
            ptrdiff_t offset = bigChildPointer - base_address;
            if(offset > 0x7fff)
                throw std::runtime_error("too big for a near pointer...");
            value = uint16_t(offset & 0x7fff);
        }

        Child* operator->() const{
            return (Child*)(base_address + value);
        }

        Child const& operator*() const{
            return *(Child const*)(base_address + value);
        }

        Child& operator*(){
            return *(Child*)(base_address + value);
        }

        // do this once, before constructing any of these!
        static void setTheGlobalBaseAddress(void* here){
             base_address = here;
        }

    private:
        uint16_t value;
        static void* base_address;
};