How do I optimize small object allocations for low-latency systems?

#include 
#include 
#include 

class SmallObjectAllocator {
public:
    SmallObjectAllocator(size_t objectSize, size_t poolSize)
        : objectSize(objectSize), poolSize(poolSize) {
        allocatePool();
    }

    ~SmallObjectAllocator() {
        for (auto& ptr : pool) {
            ::operator delete(ptr);
        }
    }

    void* allocate() {
        if (freeList.empty()) {
            throw std::runtime_error("Out of memory!");
        }
        void* obj = freeList.back();
        freeList.pop_back();
        return obj;
    }

    void deallocate(void* obj) {
        freeList.push_back(obj);
    }

private:
    void allocatePool() {
        for (size_t i = 0; i < poolSize; ++i) {
            void* obj = ::operator new(objectSize);
            freeList.push_back(obj);
        }
    }

    size_t objectSize;
    size_t poolSize;
    std::vector freeList;
};

int main() {
    SmallObjectAllocator allocator(sizeof(int), 10);
    
    int* num1 = static_cast(allocator.allocate());
    *num1 = 42;
    std::cout << *num1 << std::endl;

    allocator.deallocate(num1);
    return 0;
}