Persistence of Memory

A pure C (though C++ compatible) allocator that works with mmap allowing you to retain data semi-transparently between process runs. This allows you to "run" within a persistent space without the typical overheads of file I/O, and for your memory structures to be recovered, either to continue running or to "archeologically" retrieve data from before a crash (depending on your needs and architecture).

Features

• thread safe && lock free - no blocking, no spin locks, just pure atomics
• malloc, free and realloc implementations
  • persistent_realloc isn't the footgun that realloc is (it takes void **ptr and rewrites the address on success, and returns true/false)
• archeology / forensic capabilities - rewrite pointers from previous memory spaces using persistent_ptr
• identifiable / tagged allocations - persistent_malloc_root allows "root" allocations to be tagged for later retrieval (between process runs)
• some C++ functionality
  • PersistentPtr header-only smart/fancy pointer which automatically keeps track of its allocator_space between address changes (restarts)
  • PersistentSpace header-only offset pointer & wrapper to an allocator_space, providing template alloc/free that works across restarts

Limitations

• Fixed size - the allocator currently works strictly within a single fixed region and will not attempt to acquire more memory
• No calloc equivalent - if you want clean memory, use memset after persistent_malloc
• PersistentPtr cannot be made atomic (yet)
• No C++ STL Allocator

Pointer considerations

Care needs to be taken when using raw pointers within the space, persistent_ptr can be used to archeologically recover raw pointers from a previous run, but you should treat these spaces as read only. persistent_ptr works by adjusting the pointer based on the "old" and "new" memory address of the persistent space (new_raw_ptr = old_raw_ptr - &old_raw + &new_space) but since there is only a single slot for the origin to be stored we can only adjust from a single "old" space into our "new" space. For more flexibility C code can make use of the persistent_offset_t typealias along with the ptr_to_persistent_offset and persistent_persistent_offset_to_ptr macros to convert to and from raw pointers.

For C++ code there is a persistent_mem::PersistentPtr template class which can be treated like other fancy pointers, but remain internally consistent if they are properly initialised (they must be passed a allocator_space_t* at least once).