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); }