static bool CheckPQSize(TRI_pqueue_t* pq) { char* newItems; size_t newCapacity; if (pq == NULL) { return false; } if (pq->_base._capacity >= (pq->_base._count + 1) ) { return true; } newCapacity = pq->_base._capacity * 2; // reallocate newItems = TRI_Reallocate(TRI_UNKNOWN_MEM_ZONE, pq->_base._items, newCapacity * pq->_base._itemSize); if (newItems == NULL) { return false; } // initialise the remaining memory allocated for the storage of pq (0 filled) memset(pq->_base._items + pq->_base._capacity * pq->_base._itemSize, 0, (newCapacity - pq->_base._capacity) * pq->_base._itemSize); pq->_base._items = newItems; pq->_base._capacity = newCapacity; return true; }
static int Reserve (TRI_string_buffer_t * self, const size_t size) { char* ptr; if (size < 1) { return TRI_ERROR_NO_ERROR; } if (size > Remaining(self)) { ptrdiff_t off; size_t len; off = self->_current - self->_buffer; len = (size_t) (1.2 * (self->_len + size)); assert(len > 0); ptr = TRI_Reallocate(self->_memoryZone, self->_buffer, len + 1); if (ptr == NULL) { return TRI_ERROR_OUT_OF_MEMORY; } self->_buffer = ptr; self->_len = len; self->_current = self->_buffer + off; memset(self->_current, 0, Remaining(self) + 1); } return TRI_ERROR_NO_ERROR; }
static bool IncreaseIndexStorageSelectResult (TRI_select_result_t* result, const size_t numNeeded) { TRI_sr_index_t* start; size_t newSize; // Extend by at least INDEX_GROWTH_FACTOR to save the cost of at least some // reallocations newSize = (size_t) result->_index._numAllocated + numNeeded; if (newSize < (size_t) (result->_index._numAllocated * INDEX_GROWTH_FACTOR)) { newSize = (size_t) (result->_index._numAllocated * INDEX_GROWTH_FACTOR); } assert(newSize > result->_index._numAllocated); start = TRI_Reallocate(result->_index._start, newSize * sizeof(TRI_sr_index_t)); if (!start) { return false; } result->_index._numAllocated = newSize; // number of entries allocated // Index start pointer might have been moved by realloc, so save the new // position and calculate the end position result->_index._start = start; result->_index._current = ((TRI_sr_index_t*) start) + result->_index._numUsed; return true; }
int TRI_InsertVectorString (TRI_vector_string_t* vector, char* element, size_t n) { // ........................................................................... // Check and see if we need to extend the vector // ........................................................................... if (n >= vector->_capacity || n >= vector->_length) { char** newBuffer; size_t newSize = (size_t) (1 + GROW_FACTOR * vector->_capacity); if (n >= newSize) { newSize = n + 1; } newBuffer = (char**) TRI_Reallocate(vector->_memoryZone, vector->_buffer, newSize * sizeof(char*)); if (newBuffer == NULL) { return TRI_ERROR_OUT_OF_MEMORY; } vector->_capacity = newSize; vector->_buffer = newBuffer; } if (n != vector->_length) { memmove(vector->_buffer + n + 1, vector->_buffer + n, sizeof(char**) * (vector->_length - n)); } vector->_length++; vector->_buffer[n] = element; return TRI_ERROR_NO_ERROR; }
static TRI_fulltext_list_t* IncreaseList(TRI_fulltext_list_t* list, uint32_t size) { TRI_fulltext_list_t* copy = TRI_Reallocate(TRI_UNKNOWN_MEM_ZONE, list, MemoryList(size)); if (copy != nullptr) { InitList(copy, size); } return copy; }
static TRI_fulltext_list_t* IncreaseList (TRI_fulltext_list_t* list, const uint32_t size) { TRI_fulltext_list_t* copy; copy = TRI_Reallocate(TRI_UNKNOWN_MEM_ZONE, list, MemoryList(size)); if (copy == NULL) { // out of memory return NULL; } InitList(copy, size); return copy; }
int TRI_PushBackVectorString (TRI_vector_string_t* vector, char* element) { if (vector->_length == vector->_capacity) { char** newBuffer; size_t newSize = (size_t) (1 + GROW_FACTOR * vector->_capacity); newBuffer = (char**) TRI_Reallocate(vector->_memoryZone, vector->_buffer, newSize * sizeof(char*)); if (newBuffer == NULL) { return TRI_ERROR_OUT_OF_MEMORY; } vector->_capacity = newSize; vector->_buffer = newBuffer; } vector->_buffer[vector->_length++] = element; return TRI_ERROR_NO_ERROR; }
static bool IncreaseDocumentsStorageSelectResult (TRI_select_result_t* result, const size_t bytesNeeded) { TRI_sr_documents_t* start; TRI_sr_index_t* indexStart; TRI_sr_index_t* indexEnd; TRI_sr_index_t value; size_t diff; size_t newSize; // Extend by at least RESULT_GROWTH_FACTOR to save the cost of at least some // reallocations newSize = (size_t) result->_documents._bytesAllocated + bytesNeeded; if (newSize < (size_t) (result->_documents._bytesAllocated * RESULT_GROWTH_FACTOR)) { newSize = (size_t) (result->_documents._bytesAllocated * RESULT_GROWTH_FACTOR); } assert(newSize > result->_documents._bytesAllocated); start = (TRI_sr_documents_t*) TRI_Reallocate(result->_documents._start, newSize); if (!start) { return false; } // calc movement diff = start - (TRI_sr_documents_t*) result->_documents._start; // realloc might move the data. if it does, we need to adjust the index as well if ((start != result->_documents._start) && (result->_documents._start != 0)) { // data was moved, now adjust entries in index indexStart = (TRI_sr_index_t*) result->_index._start; indexEnd = (TRI_sr_index_t*) result->_index._current; while (indexStart < indexEnd) { value = *indexStart; *indexStart++ = (TRI_sr_index_t) (((TRI_sr_index_t*) value) + diff); } } result->_documents._bytesAllocated = newSize; result->_documents._start = start; result->_documents._current = result->_documents._current + diff; return true; }
int TRI_InsertVectorPointer (TRI_vector_pointer_t* vector, void* element, size_t n) { // ........................................................................... // Check and see if we need to extend the vector // ........................................................................... if (vector->_length >= vector->_capacity || n >= vector->_length) { void* newBuffer; size_t newSize = (size_t) (1 + GROW_FACTOR * vector->_capacity); if (n >= newSize) { newSize = n + 1; } newBuffer = TRI_Reallocate(vector->_memoryZone, vector->_buffer, newSize * sizeof(void*)); if (newBuffer == NULL) { return TRI_ERROR_OUT_OF_MEMORY; } vector->_buffer = newBuffer; // prefill the new vector elements with 0's memset(&vector->_buffer[vector->_capacity], 0, (newSize - vector->_capacity) * sizeof(void*)); vector->_capacity = newSize; } if (n < vector->_length) { memmove(vector->_buffer + n + 1, vector->_buffer + n, sizeof(void*) * (vector->_length - n)); } vector->_buffer[n] = element; if (n > vector->_length) { vector->_length = n + 1; } else { ++vector->_length; } return TRI_ERROR_NO_ERROR; }
int TRI_PushBackVectorPointer (TRI_vector_pointer_t* vector, void* element) { if (vector->_length == vector->_capacity) { void* newBuffer; size_t newSize = (size_t) (1 + GROW_FACTOR * vector->_capacity); newBuffer = TRI_Reallocate(vector->_memoryZone, vector->_buffer, newSize * sizeof(void*)); if (newBuffer == NULL) { return TRI_ERROR_OUT_OF_MEMORY; } vector->_buffer = newBuffer; // prefill the new vector elements with 0's memset(&vector->_buffer[vector->_capacity], 0, (newSize - vector->_capacity) * sizeof(void*)); vector->_capacity = newSize; } vector->_buffer[vector->_length++] = element; return TRI_ERROR_NO_ERROR; }
int TRI_PushBackVector (TRI_vector_t* vector, void const* element) { if (vector->_length == vector->_capacity) { char* newBuffer; size_t newSize = (size_t) (1 + (vector->_growthFactor * vector->_capacity)); newBuffer = (char*) TRI_Reallocate(vector->_memoryZone, vector->_buffer, newSize * vector->_elementSize); if (newBuffer == NULL) { return TRI_ERROR_OUT_OF_MEMORY; } vector->_capacity = newSize; vector->_buffer = newBuffer; } memcpy(vector->_buffer + vector->_length * vector->_elementSize, element, vector->_elementSize); vector->_length++; return TRI_ERROR_NO_ERROR; }
int TRI_ResizeVectorString (TRI_vector_string_t* vector, size_t n) { if (vector->_length == n) { return TRI_ERROR_NO_ERROR; } if (vector->_capacity < n) { void* newBuffer; size_t newSize = n; newBuffer = TRI_Reallocate(vector->_memoryZone, vector->_buffer, newSize * sizeof(char*)); if (newBuffer == NULL) { return TRI_ERROR_OUT_OF_MEMORY; } vector->_capacity = n; vector->_buffer = newBuffer; } vector->_length = n; return TRI_ERROR_NO_ERROR; }
int TRI_ResizeVector (TRI_vector_t* vector, size_t n) { if (vector->_length == n) { return TRI_ERROR_NO_ERROR; } if (vector->_capacity < n) { char* newBuffer; size_t newSize = n; newBuffer = (char*) TRI_Reallocate(vector->_memoryZone, vector->_buffer, newSize * vector->_elementSize); if (newBuffer == NULL) { return TRI_ERROR_OUT_OF_MEMORY; } vector->_capacity = n; vector->_buffer = newBuffer; } vector->_length = n; return TRI_ERROR_NO_ERROR; }
void* TRI_ReallocateZ (TRI_memory_zone_t* zone, void* m, uint64_t n, char const* file, int line) { #else void* TRI_Reallocate (TRI_memory_zone_t* zone, void* m, uint64_t n) { #endif if (m == nullptr) { #ifdef TRI_ENABLE_MAINTAINER_MODE return TRI_AllocateZ(zone, n, false, file, line); #else return TRI_Allocate(zone, n, false); #endif } char* p = (char*) m; #ifdef TRI_ENABLE_MAINTAINER_MODE CheckSize(n, file, line); #endif p = static_cast<char*>(REALLOC_WRAPPER(zone, p, (size_t) n)); if (p == nullptr) { if (zone->_failable) { TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY); return nullptr; } if (CoreReserve == nullptr) { fprintf(stderr, "FATAL: failed to re-allocate %llu bytes for memory zone %d" ZONE_DEBUG_LOCATION ", giving up!\n", (unsigned long long) n, zone->_zid ZONE_DEBUG_PARAMS); TRI_EXIT_FUNCTION(EXIT_FAILURE, nullptr); } free(CoreReserve); CoreReserve = nullptr; fprintf(stderr, "failed to re-allocate %llu bytes for memory zone %d" ZONE_DEBUG_LOCATION ", retrying!\n", (unsigned long long) n, (int) zone->_zid ZONE_DEBUG_PARAMS); #ifdef TRI_ENABLE_MAINTAINER_MODE return TRI_ReallocateZ(zone, m, n, file, line); #else return TRI_Reallocate(zone, m, n); #endif } return p; } //////////////////////////////////////////////////////////////////////////////// /// @brief basic memory management for deallocate //////////////////////////////////////////////////////////////////////////////// #ifdef TRI_ENABLE_MAINTAINER_MODE void TRI_FreeZ (TRI_memory_zone_t* zone, void* m, char const* file, int line) { #else void TRI_Free (TRI_memory_zone_t* zone, void* m) { #endif char* p = (char*) m; #ifdef TRI_ENABLE_MAINTAINER_MODE if (p == nullptr) { fprintf(stderr, "freeing nil ptr " ZONE_DEBUG_LOCATION ZONE_DEBUG_PARAMS); // crash intentionally TRI_ASSERT(false); } #endif free(p); }