Method splitMemoryUnit

src/memory/HeapAllocator.cpp:78–118

Split a memory unit in two units. One of size "size" and the second with left over space. The second unit is put into the free memory units

/// Split a memory unit in two units. One of size "size" and the second with
/// left over space. The second unit is put into the free memory units
void HeapAllocator::splitMemoryUnit(MemoryUnitHeader* unit, size_t size) {

    assert(!unit->isAllocated);

    // If the size of the unit is large enough to be slit
    if (size + sizeof(MemoryUnitHeader) < unit->size) {

        // Create a new memory unit with left over space
        unsigned char* newUnitLocation = (reinterpret_cast<unsigned char*>(unit)) + sizeof(MemoryUnitHeader) + size;
        MemoryUnitHeader* newUnit = new (static_cast<void*>(newUnitLocation)) MemoryUnitHeader(unit->size - sizeof(MemoryUnitHeader) - size, unit, unit->nextUnit, unit, unit->nextFreeUnit, unit->isNextContiguousMemory);
        assert(newUnit->nextUnit != newUnit);
        unit->nextUnit = newUnit;
        unit->nextFreeUnit = newUnit;
        if (newUnit->nextUnit != nullptr) {
            newUnit->nextUnit->previousUnit = newUnit;
        }
        if (newUnit->nextFreeUnit != nullptr) {
            newUnit->nextFreeUnit->previousFreeUnit = newUnit;
        }

        assert(unit->nextUnit != unit);
        unit->isNextContiguousMemory = true;
        unit->size = size;

       assert(unit->previousUnit == nullptr || unit->previousUnit->nextUnit == unit);
       assert(unit->nextUnit == nullptr || unit->nextUnit->previousUnit == unit);

       assert(unit->previousFreeUnit == nullptr || unit->previousFreeUnit->nextFreeUnit == unit);
       assert(unit->nextFreeUnit == nullptr || unit->nextFreeUnit->previousFreeUnit == unit);

       assert(newUnit->previousUnit == nullptr || newUnit->previousUnit->nextUnit == newUnit);
       assert(newUnit->nextUnit == nullptr || newUnit->nextUnit->previousUnit == newUnit);

       assert(newUnit->previousFreeUnit->nextFreeUnit == newUnit);
       assert(newUnit->nextFreeUnit == nullptr || newUnit->nextFreeUnit->previousFreeUnit == newUnit);

       assert(unit->nextFreeUnit == newUnit);
       assert(newUnit->previousFreeUnit == unit);
       assert(!newUnit->isAllocated);
   }
}

// Allocate memory of a given size (in bytes) and return a pointer to the
// allocated memory.