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