Error PodVectorBase::_grow(size_t n, size_t sizeOfT) noexcept {
Data* d = _d;
size_t threshold = kMemAllocGrowMax / sizeOfT;
size_t capacity = d->capacity;
size_t after = d->length;
if (IntTraits<size_t>::maxValue() - n < after)
return kErrorNoHeapMemory;
after += n;
if (capacity >= after)
return kErrorOk;
// PodVector is used as a linear array for some data structures used by
// AsmJit code generation. The purpose of this agressive growing schema
// is to minimize memory reallocations, because AsmJit code generation
// classes live short life and will be freed or reused soon.
if (capacity < 32)
capacity = 32;
else if (capacity < 128)
capacity = 128;
else if (capacity < 512)
capacity = 512;
while (capacity < after) {
if (capacity < threshold)
capacity *= 2;
else
capacity += threshold;
}
return _reserve(capacity, sizeOfT);
}
void MemoryDebugger::clean(void)
{
if (_CleanAllowed && (_size() < _capacity() / 2))
{
_reserve(_size() + 16);
}
}
Error Assembler::_grow(size_t n) {
size_t capacity = getCapacity();
size_t after = getOffset() + n;
// Overflow.
if (n > IntUtil::maxUInt<uintptr_t>() - capacity)
return setError(kErrorNoHeapMemory);
// Grow is called when allocation is needed, so it shouldn't happen, but on
// the other hand it is simple to catch and it's not an error.
if (after <= capacity)
return kErrorOk;
if (capacity < kMemAllocOverhead)
capacity = kMemAllocOverhead;
else
capacity += kMemAllocOverhead;
do {
size_t oldCapacity = capacity;
if (capacity < kMemAllocGrowMax)
capacity *= 2;
else
capacity += kMemAllocGrowMax;
// Overflow.
if (oldCapacity > capacity)
return setError(kErrorNoHeapMemory);
} while (capacity - kMemAllocOverhead < after);
capacity -= kMemAllocOverhead;
return _reserve(capacity);
}
void str_set(str_t* str, const char* src) {
size_t len = strlen(src);
_reserve(str, len + 1);
strncpy(str->buf.base, src, len + 1);
str->buf.len = len;
}
MemoryDebugger::MemoryDebugger(void)
: _First(0),
_Last(0),
_End(0),
_CleanAllowed(true)
{
// Reserve ~NxOgreMemoryDebuggerInitialAllocationSize of space for early allocations.
_reserve((NxOgreMemoryDebuggerInitialAllocationSize / sizeof(MemoryAllocation)));
}
void str_format(str_t* str, const char* fmt, ...) {
va_list argp;
va_start(argp, fmt);
size_t len = vsnprintf(NULL, 0, fmt, argp) + 1;
_reserve(str, len);
va_start(argp, fmt);
vsnprintf(str->buf.base, len, fmt, argp);
str->buf.len = len - 1;
}
void* MemoryDebugger::addAllocation(void* ptr, size_t size, unsigned int class_id, const char* file, unsigned int line)
{
if (_End <= _Last)
_reserve((1 + _size()) * 2);
_Last->_Ptr = ptr;
_Last->_Size = size;
_Last->_Type = class_id;
_Last->_File = file;
_Last->_Line = line;
_Last++;
return ptr;
}
void str_cat_format(str_t* str, const char* fmt, ...) {
va_list argp;
va_start(argp, fmt);
size_t len = vsnprintf(NULL, 0, fmt, argp) + 1;
size_t new_len = str->buf.len + len;
_reserve(str, new_len);
// TODO: Fix me
va_start(argp, fmt);
char* buf = (char*)str->buf.base;
vsnprintf(buf + str->buf.len, len + 1, fmt, argp);
str->buf.len = new_len - 1;
}
void str_append_len(str_t* str, const char* data, size_t len) {
// TODO: assert?
if (len == 0)
return;
// Extend buffer if necessary
size_t new_len = str->buf.len + len;
_reserve(str, new_len + 1);
// Copy string
char* buf = (char*)str->buf.base;
memcpy(buf + str->buf.len, data, len);
buf[new_len] = '\0';
str->buf.len = new_len;
}
/** Reserves internal storage for n elements.
*/
void reserve(size_t n) { _reserve(n); }
