Examples with OCacheEntry com.orientechnologies.orient.core.storage.cache.OCacheEntry used on opensource projects

Example 91 with OCacheEntry

use of com.orientechnologies.orient.core.storage.cache.OCacheEntry in project orientdb by orientechnologies.

the class OSBTreeBonsaiLocal method findBucket.

private BucketSearchResult findBucket(K key, OAtomicOperation atomicOperation) throws IOException {
    OBonsaiBucketPointer bucketPointer = rootBucketPointer;
    final ArrayList<OBonsaiBucketPointer> path = new ArrayList<OBonsaiBucketPointer>();
    while (true) {
        path.add(bucketPointer);
        final OCacheEntry bucketEntry = loadPage(atomicOperation, fileId, bucketPointer.getPageIndex(), false);
        bucketEntry.acquireSharedLock();
        final OSBTreeBonsaiBucket.SBTreeEntry<K, V> entry;
        try {
            final OSBTreeBonsaiBucket<K, V> keyBucket = new OSBTreeBonsaiBucket<K, V>(bucketEntry, bucketPointer.getPageOffset(), keySerializer, valueSerializer, getChanges(atomicOperation, bucketEntry), this);
            final int index = keyBucket.find(key);
            if (keyBucket.isLeaf())
                return new BucketSearchResult(index, path);
            if (index >= 0)
                entry = keyBucket.getEntry(index);
            else {
                final int insertionIndex = -index - 1;
                if (insertionIndex >= keyBucket.size())
                    entry = keyBucket.getEntry(insertionIndex - 1);
                else
                    entry = keyBucket.getEntry(insertionIndex);
            }
        } finally {
            bucketEntry.releaseSharedLock();
            releasePage(atomicOperation, bucketEntry);
        }
        if (comparator.compare(key, entry.key) >= 0)
            bucketPointer = entry.rightChild;
        else
            bucketPointer = entry.leftChild;
    }
}

Example 92 with OCacheEntry

use of com.orientechnologies.orient.core.storage.cache.OCacheEntry in project orientdb by orientechnologies.

the class OLocalHashTable method floorEntries.

@Override
public OHashIndexBucket.Entry<K, V>[] floorEntries(K key) {
    startOperation();
    try {
        atomicOperationsManager.acquireReadLock(this);
        try {
            acquireSharedLock();
            try {
                OAtomicOperation atomicOperation = atomicOperationsManager.getCurrentOperation();
                key = keySerializer.preprocess(key, (Object[]) keyTypes);
                final long hashCode = keyHashFunction.hashCode(key);
                OHashTable.BucketPath bucketPath = getBucket(hashCode);
                long bucketPointer = directory.getNodePointer(bucketPath.nodeIndex, bucketPath.itemIndex + bucketPath.hashMapOffset);
                long pageIndex = getPageIndex(bucketPointer);
                OCacheEntry cacheEntry = loadPage(atomicOperation, fileId, pageIndex, false);
                cacheEntry.acquireSharedLock();
                try {
                    OHashIndexBucket<K, V> bucket = new OHashIndexBucket<K, V>(cacheEntry, keySerializer, valueSerializer, keyTypes, getChanges(atomicOperation, cacheEntry));
                    while (bucket.size() == 0) {
                        final OHashTable.BucketPath prevBucketPath = prevBucketToFind(bucketPath, bucket.getDepth());
                        if (prevBucketPath == null)
                            return OCommonConst.EMPTY_BUCKET_ENTRY_ARRAY;
                        cacheEntry.releaseSharedLock();
                        releasePage(atomicOperation, cacheEntry);
                        final long prevPointer = directory.getNodePointer(prevBucketPath.nodeIndex, prevBucketPath.itemIndex + prevBucketPath.hashMapOffset);
                        pageIndex = getPageIndex(prevPointer);
                        cacheEntry = loadPage(atomicOperation, fileId, pageIndex, false);
                        cacheEntry.acquireSharedLock();
                        bucket = new OHashIndexBucket<K, V>(cacheEntry, keySerializer, valueSerializer, keyTypes, getChanges(atomicOperation, cacheEntry));
                        bucketPath = prevBucketPath;
                    }
                    final int startIndex = 0;
                    final int index = bucket.getIndex(hashCode, key);
                    final int endIndex;
                    if (index >= 0)
                        endIndex = index + 1;
                    else
                        endIndex = -index - 1;
                    return convertBucketToEntries(bucket, startIndex, endIndex);
                } finally {
                    cacheEntry.releaseSharedLock();
                    releasePage(atomicOperation, cacheEntry);
                }
            } finally {
                releaseSharedLock();
            }
        } catch (IOException ioe) {
            throw OException.wrapException(new OLocalHashTableException("Exception during data read", this), ioe);
        } finally {
            atomicOperationsManager.releaseReadLock(this);
        }
    } finally {
        completeOperation();
    }
}

Example 93 with OCacheEntry

use of com.orientechnologies.orient.core.storage.cache.OCacheEntry in project orientdb by orientechnologies.

the class OLocalHashTable method changeSize.

private void changeSize(int sizeDiff, OAtomicOperation atomicOperation) throws IOException {
    if (sizeDiff != 0) {
        OCacheEntry hashStateEntry = loadPage(atomicOperation, fileStateId, hashStateEntryIndex, true);
        hashStateEntry.acquireExclusiveLock();
        try {
            OHashIndexFileLevelMetadataPage page = new OHashIndexFileLevelMetadataPage(hashStateEntry, getChanges(atomicOperation, hashStateEntry), false);
            page.setRecordsCount(page.getRecordsCount() + sizeDiff);
        } finally {
            hashStateEntry.releaseExclusiveLock();
            releasePage(atomicOperation, hashStateEntry);
        }
    }
}

Example 94 with OCacheEntry

use of com.orientechnologies.orient.core.storage.cache.OCacheEntry in project orientdb by orientechnologies.

the class OLocalHashTable method splitBucket.

private OHashTable.BucketSplitResult splitBucket(OHashIndexBucket<K, V> bucket, long pageIndex, OAtomicOperation atomicOperation) throws IOException {
    int bucketDepth = bucket.getDepth();
    int newBucketDepth = bucketDepth + 1;
    final long updatedBucketIndex = pageIndex;
    final OCacheEntry newBucketCacheEntry = addPage(atomicOperation, fileId);
    newBucketCacheEntry.acquireExclusiveLock();
    try {
        final OHashIndexBucket<K, V> newBucket = new OHashIndexBucket<K, V>(newBucketDepth, newBucketCacheEntry, keySerializer, valueSerializer, keyTypes, getChanges(atomicOperation, newBucketCacheEntry));
        splitBucketContent(bucket, newBucket, newBucketDepth);
        final long updatedBucketPointer = createBucketPointer(updatedBucketIndex);
        final long newBucketPointer = createBucketPointer(newBucketCacheEntry.getPageIndex());
        return new OHashTable.BucketSplitResult(updatedBucketPointer, newBucketPointer, newBucketDepth);
    } finally {
        newBucketCacheEntry.releaseExclusiveLock();
        releasePage(atomicOperation, newBucketCacheEntry);
    }
}

Example 95 with OCacheEntry

use of com.orientechnologies.orient.core.storage.cache.OCacheEntry in project orientdb by orientechnologies.

the class OLocalHashTable method remove.

@Override
public V remove(K key) {
    final OSessionStoragePerformanceStatistic statistic = performanceStatisticManager.getSessionPerformanceStatistic();
    startOperation();
    if (statistic != null)
        statistic.startIndexEntryDeletionTimer();
    try {
        final OAtomicOperation atomicOperation;
        try {
            atomicOperation = startAtomicOperation(true);
        } catch (IOException e) {
            throw OException.wrapException(new OIndexException("Error during hash table entry deletion"), e);
        }
        acquireExclusiveLock();
        try {
            checkNullSupport(key);
            int sizeDiff = 0;
            if (key != null) {
                key = keySerializer.preprocess(key, (Object[]) keyTypes);
                final long hashCode = keyHashFunction.hashCode(key);
                final OHashTable.BucketPath nodePath = getBucket(hashCode);
                final long bucketPointer = directory.getNodePointer(nodePath.nodeIndex, nodePath.itemIndex + nodePath.hashMapOffset);
                final long pageIndex = getPageIndex(bucketPointer);
                final V removed;
                final boolean found;
                final OCacheEntry cacheEntry = loadPage(atomicOperation, fileId, pageIndex, false);
                cacheEntry.acquireExclusiveLock();
                try {
                    final OHashIndexBucket<K, V> bucket = new OHashIndexBucket<K, V>(cacheEntry, keySerializer, valueSerializer, keyTypes, getChanges(atomicOperation, cacheEntry));
                    final int positionIndex = bucket.getIndex(hashCode, key);
                    found = positionIndex >= 0;
                    if (found) {
                        removed = bucket.deleteEntry(positionIndex).value;
                        sizeDiff--;
                    } else
                        removed = null;
                } finally {
                    cacheEntry.releaseExclusiveLock();
                    releasePage(atomicOperation, cacheEntry);
                }
                if (found) {
                    if (nodePath.parent != null) {
                        final int hashMapSize = 1 << nodePath.nodeLocalDepth;
                        final boolean allMapsContainSameBucket = checkAllMapsContainSameBucket(directory.getNode(nodePath.nodeIndex), hashMapSize);
                        if (allMapsContainSameBucket)
                            mergeNodeToParent(nodePath);
                    }
                    changeSize(sizeDiff, atomicOperation);
                }
                endAtomicOperation(false, null);
                return removed;
            } else {
                if (getFilledUpTo(atomicOperation, nullBucketFileId) == 0) {
                    endAtomicOperation(false, null);
                    return null;
                }
                V removed = null;
                OCacheEntry cacheEntry = loadPage(atomicOperation, nullBucketFileId, 0, false);
                if (cacheEntry == null)
                    cacheEntry = addPage(atomicOperation, nullBucketFileId);
                cacheEntry.acquireExclusiveLock();
                try {
                    final ONullBucket<V> nullBucket = new ONullBucket<V>(cacheEntry, getChanges(atomicOperation, cacheEntry), valueSerializer, false);
                    removed = nullBucket.getValue();
                    if (removed != null) {
                        nullBucket.removeValue();
                        sizeDiff--;
                    }
                } finally {
                    cacheEntry.releaseExclusiveLock();
                    releasePage(atomicOperation, cacheEntry);
                }
                changeSize(sizeDiff, atomicOperation);
                endAtomicOperation(false, null);
                return removed;
            }
        } catch (IOException e) {
            rollback(e);
            throw OException.wrapException(new OIndexException("Error during index removal"), e);
        } catch (Exception e) {
            rollback(e);
            throw OException.wrapException(new OStorageException("Error during index removal"), e);
        } finally {
            releaseExclusiveLock();
        }
    } finally {
        if (statistic != null)
            statistic.stopIndexEntryDeletionTimer();
        completeOperation();
    }
}