Passing dependency in allocator - c++

Question

I've been making interpreter for prototype-based language .
And i found problem i dont know how to solve .
Objects are splited into actual object and object map with slots. Both of them are allocated into heap that is under control of GC.
Implementation of operator new in Object and ObjectMap are practically same:
void* Objects::Object::operator new(size_t size) {
return Universe::getUniverse()->allocateMemory(size);
}
Universe is implemented as singleton that contains pointer to other parts of virtual machine (interpreter , object heap etc.).
This design cant be used with unit tests so i wanted to rewrite it into something like this soo i will be able to inject different heap during testing:
void* Objects::Object::operator new(size_t size, ObjectHeap* objectHeap) {
return objectHeap->allocateMemory(size);
}
But i found problem.
Object is creating new ObjectMap in constructor (ObjectMap is using same implementation of operator new):
Objects::Object::Object(unsigned char numberOfSlots) {
this->forwadingPointer = nullptr;
this->objectMap = new Object_Layout::ObjectMap(numberOfSlots);
}
Is there any way to pass that injection into allocator for ObjectMap (when i create Object using heap , Object Map created by Object will be in same heap) ?

Answer 1

This method will allow you to use a custom memory manager for everything in your unit tests.
You can't use new inside your custom memory manager or it will cause infinite recursion, though.
universe..hh
class Universe
{
public:
static Universe * getUniverse();
};
universe.cc
#include "universe.hh"
Universe * Universe::getUniverse() {
return new Universe;
}
main.cc
#include "universe.hh"
namespace myalloc {
class IAllocator
{
public:
virtual void * allocateMemory (size_t size) = 0;
};
//
// Your heap
//
class MyAllocator : public IAllocator
{
public:
void * allocateMemory (size_t size) {
return ::malloc(size); // call your heap allocator (not 'new'!)
}
};
//
// Unit testing heap
//
class DebugingAllocator : public IAllocator
{
public:
enum e_modes {
e_alloc, // 0 will get memory
e_bad_alloc
};
void setMode (int m) { _mode = m; }
void * allocateMemory (size_t size) {
void * buf {nullptr};
switch (_mode) {
case e_bad_alloc:
throw std::bad_alloc();
break;
case e_alloc:
default:
buf = ::malloc(size); // my testing allocator
break;
}
return buf;
}
private:
int _mode {0};
};
class MyAllocatorHandler {
public:
static void setAllocator (IAllocator * allocatorMock) {
_allocator_ptr = allocatorMock;
}
static IAllocator * getAllocator () { return _allocator_ptr; }
private:
static MyAllocator _allocator;
static IAllocator * _allocator_ptr;
};
MyAllocator MyAllocatorHandler::_allocator;
IAllocator * MyAllocatorHandler::_allocator_ptr {&MyAllocatorHandler::_allocator};
} // end namespace myalloc
#ifdef UNIT_TEST
void * operator new (size_t size) {
std::cerr << "Debug new operator. Alloc " << size << " bytes." << std::endl;
return myalloc::MyAllocatorHandler::getAllocator()->allocateMemory(size);
}
void operator delete (void * buf) {
std::cerr << "Debug delete operator." << std::endl;
::free (buf);
}
#endif
int main ()
{
// create a unit test allocator
myalloc::DebugingAllocator da;
// change allocator to simulate error conditions
myalloc::MyAllocatorHandler::setAllocator (&da);
// no failure for allocation
Universe * univ = Universe::getUniverse();
// set failure mode
da.setMode (myalloc::DebugingAllocator::e_bad_alloc);
try {
// it will fail even in other libraries...
//std::string str ("This is a long sentence to avoid small buffer optimizations.");
std::cout << "Try to allocate." << std::endl;
Universe * univ1 = Universe::getUniverse();
// we aren't going to arrive here in UNIT_TEST mode
std::cout << "Can't we see this?"
<< std::endl;
delete univ1;
} catch (std::bad_alloc & ex) {
std::cerr << "Bad alloc, as expected." << std::endl;
}
delete univ;
return 0;
}

Answer 2

Ok only way to do this is using factory method to create objects
Objects::Object* Objects::Object::create(Memory::ObjectSpace* memory, unsigned char numberOfSlots){
return new(memory) Object(memory, numberOfSlots);
}
I will pass memory object that i want use and static method will pass it into allocator and constructor.
Constructor will pass memory parameter into constructor of ObjectMap.
Objects::Object::Object(Memory::ObjectSpace* memory, unsigned char numberOfSlots) {
this->forwadingPointer = nullptr;
this->objectMap = new(memory) Object_Layout::ObjectMap(memory, numberOfSlots);
}
It will be better to add factory method into ObjectMap too.
Thanks to Silvio Mayolo for idea.