static void DecreaseRefCount (TRI_shadow_store_t* const store, TRI_shadow_t* const shadow) { LOG_TRACE("decreasing refcount for shadow %p with data ptr %p and id %llu to %d", shadow, shadow->_data, (unsigned long long) shadow->_id, (int) (shadow->_rc - 1)); if (--shadow->_rc <= 0 && shadow->_type == SHADOW_TRANSIENT) { LOG_TRACE("deleting transient shadow %p", shadow); TRI_RemoveKeyAssociativePointer(&store->_ids, &shadow->_id); TRI_RemoveKeyAssociativePointer(&store->_pointers, shadow->_data); store->destroyShadow(shadow->_data); TRI_Free(TRI_UNKNOWN_MEM_ZONE, shadow); } }
void TRI_RemoveLinkedArray (TRI_linked_array_t* array, void const* data) { TRI_linked_list_entry_t* found; found = TRI_RemoveKeyAssociativePointer(&array->_array, data); if (found != NULL) { TRI_RemoveLinkedList(&array->_list, found); TRI_Free(array->_memoryZone, found); } }
static TRI_shape_aid_t FindAttributeNameArrayShaper (TRI_shaper_t* shaper, char const* name) { array_shaper_t* s; void const* p; s = (array_shaper_t*) shaper; p = TRI_LookupByKeyAssociativePointer(&s->_attributeNames, name); if (p == NULL) { size_t n; attribute_2_id_t* a2i; void* f; int res; n = strlen(name) + 1; a2i = TRI_Allocate(shaper->_memoryZone, sizeof(attribute_2_id_t) + n, false); if (a2i == NULL) { return 0; } a2i->_aid = 1 + s->_attributes._length; a2i->_size = n; memcpy(((char*) a2i) + sizeof(attribute_2_id_t), name, n); f = TRI_InsertKeyAssociativePointer(&s->_attributeNames, name, a2i, false); if (f == NULL) { TRI_Free(shaper->_memoryZone, a2i); return 0; } res = TRI_PushBackVectorPointer(&s->_attributes, a2i); if (res != TRI_ERROR_NO_ERROR) { TRI_RemoveKeyAssociativePointer(&s->_attributeNames, name); TRI_Free(shaper->_memoryZone, a2i); return 0; } return a2i->_aid; } else { attribute_2_id_t const* a2i = (attribute_2_id_t const*) p; return a2i->_aid; } }
void TRI_CleanupGeneralCursor (TRI_general_cursor_store_t* store, bool force) { double compareStamp = TRI_microtime(); size_t deleteCount = 0; // we need an exclusive lock on the index TRI_LockSpin(&store->_lock); if (store->_ids._nrUsed == 0) { // store is empty, nothing to do! TRI_UnlockSpin(&store->_lock); return; } LOG_TRACE("cleaning shadows. in store: %ld", (unsigned long) store->_ids._nrUsed); // loop until there's nothing to delete or // we have deleted CURSOR_MAX_DELETE elements while (deleteCount++ < CURSOR_MAX_DELETE || force) { bool deleted = false; size_t i; for (i = 0; i < store->_ids._nrAlloc; i++) { // enum all cursors TRI_general_cursor_t* cursor = (TRI_general_cursor_t*) store->_ids._table[i]; if (cursor == NULL) { continue; } TRI_LockSpin(&cursor->_lock); if (force || (cursor->_usage._refCount == 0 && (cursor->_usage._isDeleted || cursor->_expires < compareStamp))) { LOG_TRACE("cleaning cursor %p, id: %llu, rc: %d, expires: %d, deleted: %d", cursor, (unsigned long long) cursor->_id, (int) cursor->_usage._refCount, (int) cursor->_expires, (int) cursor->_usage._isDeleted); TRI_RemoveKeyAssociativePointer(&store->_ids, &cursor->_id); TRI_UnlockSpin(&cursor->_lock); TRI_FreeGeneralCursor(cursor); deleted = true; // the remove might reposition elements in the container. // therefore break here and start iteration anew break; } TRI_UnlockSpin(&cursor->_lock); } if (! deleted) { // we did not find anything to delete, so give up break; } } // release lock TRI_UnlockSpin(&store->_lock); }
void TRI_RemoveDatafileInfoPrimaryCollection (TRI_primary_collection_t* primary, TRI_voc_fid_t fid) { TRI_RemoveKeyAssociativePointer(&primary->_datafileInfo, &fid); }
void TRI_CleanupShadowData (TRI_shadow_store_t* const store, const double maxAge, const bool force) { double compareStamp = TRI_microtime() - maxAge; // age must be specified in secs size_t deleteCount = 0; // we need an exclusive lock on the index TRI_LockMutex(&store->_lock); if (store->_ids._nrUsed == 0) { // store is empty, nothing to do! TRI_UnlockMutex(&store->_lock); return; } LOG_TRACE("cleaning shadows. in store: %ld", (unsigned long) store->_ids._nrUsed); // loop until there's nothing to delete or // we have deleted SHADOW_MAX_DELETE elements while (deleteCount++ < SHADOW_MAX_DELETE || force) { bool deleted = false; size_t i; for (i = 0; i < store->_ids._nrAlloc; i++) { // enum all shadows TRI_shadow_t* shadow = (TRI_shadow_t*) store->_ids._table[i]; if (shadow == NULL) { continue; } // check if shadow is unused and expired if (shadow->_rc < 1 || force) { if (shadow->_type == SHADOW_TRANSIENT || shadow->_timestamp < compareStamp || shadow->_deleted || force) { LOG_TRACE("cleaning shadow %p, id: %llu, rc: %d, expired: %d, deleted: %d", shadow, (unsigned long long) shadow->_id, (int) shadow->_rc, (int) (shadow->_timestamp < compareStamp), (int) shadow->_deleted); TRI_RemoveKeyAssociativePointer(&store->_ids, &shadow->_id); TRI_RemoveKeyAssociativePointer(&store->_pointers, shadow->_data); store->destroyShadow(shadow->_data); TRI_Free(TRI_UNKNOWN_MEM_ZONE, shadow); deleted = true; // the remove might reposition elements in the container. // therefore break here and start iteration anew break; } } } if (! deleted) { // we did not find anything to delete, so give up break; } } // release lock TRI_UnlockMutex(&store->_lock); }