Examples with OSessionStoragePerformanceStatistic com.orientechnologies.orient.core.storage.impl.local.statistic.OSessionStoragePerformanceStatistic used on opensource projects

Example 6 with OSessionStoragePerformanceStatistic

use of com.orientechnologies.orient.core.storage.impl.local.statistic.OSessionStoragePerformanceStatistic in project orientdb by orientechnologies.

the class OSBTree method get.

public V get(K key) {
    final OSessionStoragePerformanceStatistic statistic = performanceStatisticManager.getSessionPerformanceStatistic();
    startOperation();
    if (statistic != null)
        statistic.startIndexEntryReadTimer();
    try {
        atomicOperationsManager.acquireReadLock(this);
        try {
            acquireSharedLock();
            try {
                checkNullSupport(key);
                OAtomicOperation atomicOperation = atomicOperationsManager.getCurrentOperation();
                if (key != null) {
                    key = keySerializer.preprocess(key, (Object[]) keyTypes);
                    BucketSearchResult bucketSearchResult = findBucket(key, atomicOperation);
                    if (bucketSearchResult.itemIndex < 0)
                        return null;
                    long pageIndex = bucketSearchResult.getLastPathItem();
                    OCacheEntry keyBucketCacheEntry = loadPage(atomicOperation, fileId, pageIndex, false);
                    keyBucketCacheEntry.acquireSharedLock();
                    try {
                        OSBTreeBucket<K, V> keyBucket = new OSBTreeBucket<K, V>(keyBucketCacheEntry, keySerializer, keyTypes, valueSerializer, getChanges(atomicOperation, keyBucketCacheEntry));
                        OSBTreeBucket.SBTreeEntry<K, V> treeEntry = keyBucket.getEntry(bucketSearchResult.itemIndex);
                        return readValue(treeEntry.value, atomicOperation);
                    } finally {
                        keyBucketCacheEntry.releaseSharedLock();
                        releasePage(atomicOperation, keyBucketCacheEntry);
                    }
                } else {
                    if (getFilledUpTo(atomicOperation, nullBucketFileId) == 0)
                        return null;
                    final OCacheEntry nullBucketCacheEntry = loadPage(atomicOperation, nullBucketFileId, 0, false);
                    nullBucketCacheEntry.acquireSharedLock();
                    try {
                        final ONullBucket<V> nullBucket = new ONullBucket<V>(nullBucketCacheEntry, getChanges(atomicOperation, nullBucketCacheEntry), valueSerializer, false);
                        final OSBTreeValue<V> treeValue = nullBucket.getValue();
                        if (treeValue == null)
                            return null;
                        return readValue(treeValue, atomicOperation);
                    } finally {
                        nullBucketCacheEntry.releaseSharedLock();
                        releasePage(atomicOperation, nullBucketCacheEntry);
                    }
                }
            } finally {
                releaseSharedLock();
            }
        } catch (IOException e) {
            throw OException.wrapException(new OSBTreeException("Error during retrieving  of sbtree with name " + getName(), this), e);
        } finally {
            atomicOperationsManager.releaseReadLock(this);
        }
    } finally {
        if (statistic != null)
            statistic.startIndexEntryReadTimer();
        completeOperation();
    }
}

Example 7 with OSessionStoragePerformanceStatistic

use of com.orientechnologies.orient.core.storage.impl.local.statistic.OSessionStoragePerformanceStatistic in project orientdb by orientechnologies.

the class OSBTreeBonsaiLocal method loadEntriesBetween.

@Override
public void loadEntriesBetween(K keyFrom, boolean fromInclusive, K keyTo, boolean toInclusive, RangeResultListener<K, V> listener) {
    final OSessionStoragePerformanceStatistic statistic = performanceStatisticManager.getSessionPerformanceStatistic();
    int readEntries = 0;
    startOperation();
    if (statistic != null)
        statistic.startRidBagEntryReadTimer();
    try {
        atomicOperationsManager.acquireReadLock(this);
        try {
            final Lock lock = FILE_LOCK_MANAGER.acquireSharedLock(fileId);
            try {
                OAtomicOperation atomicOperation = atomicOperationsManager.getCurrentOperation();
                BucketSearchResult bucketSearchResultFrom = findBucket(keyFrom, atomicOperation);
                OBonsaiBucketPointer bucketPointerFrom = bucketSearchResultFrom.getLastPathItem();
                int indexFrom;
                if (bucketSearchResultFrom.itemIndex >= 0) {
                    indexFrom = fromInclusive ? bucketSearchResultFrom.itemIndex : bucketSearchResultFrom.itemIndex + 1;
                } else {
                    indexFrom = -bucketSearchResultFrom.itemIndex - 1;
                }
                BucketSearchResult bucketSearchResultTo = findBucket(keyTo, atomicOperation);
                OBonsaiBucketPointer bucketPointerTo = bucketSearchResultTo.getLastPathItem();
                int indexTo;
                if (bucketSearchResultTo.itemIndex >= 0) {
                    indexTo = toInclusive ? bucketSearchResultTo.itemIndex : bucketSearchResultTo.itemIndex - 1;
                } else {
                    indexTo = -bucketSearchResultTo.itemIndex - 2;
                }
                int startIndex = indexFrom;
                int endIndex;
                OBonsaiBucketPointer bucketPointer = bucketPointerFrom;
                resultsLoop: while (true) {
                    final OCacheEntry cacheEntry = loadPage(atomicOperation, fileId, bucketPointer.getPageIndex(), false);
                    cacheEntry.acquireSharedLock();
                    try {
                        OSBTreeBonsaiBucket<K, V> bucket = new OSBTreeBonsaiBucket<K, V>(cacheEntry, bucketPointer.getPageOffset(), keySerializer, valueSerializer, getChanges(atomicOperation, cacheEntry), this);
                        if (!bucketPointer.equals(bucketPointerTo))
                            endIndex = bucket.size() - 1;
                        else
                            endIndex = indexTo;
                        for (int i = startIndex; i <= endIndex; i++) {
                            if (!listener.addResult(bucket.getEntry(i))) {
                                readEntries++;
                                break resultsLoop;
                            }
                        }
                        if (bucketPointer.equals(bucketPointerTo))
                            break;
                        bucketPointer = bucket.getRightSibling();
                        if (bucketPointer.getPageIndex() < 0)
                            break;
                    } finally {
                        cacheEntry.releaseSharedLock();
                        releasePage(atomicOperation, cacheEntry);
                    }
                    startIndex = 0;
                }
            } finally {
                lock.unlock();
            }
        } catch (IOException ioe) {
            throw OException.wrapException(new OSBTreeBonsaiLocalException("Error during fetch of values between key " + keyFrom + " and key " + keyTo + " in sbtree " + getName(), this), ioe);
        } finally {
            atomicOperationsManager.releaseReadLock(this);
        }
    } finally {
        if (statistic != null)
            statistic.stopRidBagEntryReadTimer(readEntries);
        completeOperation();
    }
}

Example 8 with OSessionStoragePerformanceStatistic

use of com.orientechnologies.orient.core.storage.impl.local.statistic.OSessionStoragePerformanceStatistic in project orientdb by orientechnologies.

the class OSBTreeBonsaiLocal method remove.

@Override
public V remove(K key) {
    final OSessionStoragePerformanceStatistic statistic = performanceStatisticManager.getSessionPerformanceStatistic();
    startOperation();
    if (statistic != null)
        statistic.startRidBagEntryDeletionTimer();
    try {
        final OAtomicOperation atomicOperation;
        try {
            atomicOperation = startAtomicOperation(true);
        } catch (IOException e) {
            throw OException.wrapException(new OSBTreeBonsaiLocalException("Error during sbtree entrie removal", this), e);
        }
        Lock lock = FILE_LOCK_MANAGER.acquireExclusiveLock(fileId);
        try {
            BucketSearchResult bucketSearchResult = findBucket(key, atomicOperation);
            if (bucketSearchResult.itemIndex < 0) {
                endAtomicOperation(false, null);
                return null;
            }
            OBonsaiBucketPointer bucketPointer = bucketSearchResult.getLastPathItem();
            OCacheEntry keyBucketCacheEntry = loadPage(atomicOperation, fileId, bucketPointer.getPageIndex(), false);
            final V removed;
            keyBucketCacheEntry.acquireExclusiveLock();
            try {
                OSBTreeBonsaiBucket<K, V> keyBucket = new OSBTreeBonsaiBucket<K, V>(keyBucketCacheEntry, bucketPointer.getPageOffset(), keySerializer, valueSerializer, getChanges(atomicOperation, keyBucketCacheEntry), this);
                removed = keyBucket.getEntry(bucketSearchResult.itemIndex).value;
                keyBucket.remove(bucketSearchResult.itemIndex);
            } finally {
                keyBucketCacheEntry.releaseExclusiveLock();
                releasePage(atomicOperation, keyBucketCacheEntry);
            }
            setSize(size() - 1, atomicOperation);
            endAtomicOperation(false, null);
            return removed;
        } catch (IOException e) {
            rollback(e);
            throw OException.wrapException(new OSBTreeBonsaiLocalException("Error during removing key " + key + " from sbtree " + getName(), this), e);
        } catch (RuntimeException e) {
            rollback(e);
            throw e;
        } finally {
            lock.unlock();
        }
    } finally {
        if (statistic != null)
            statistic.stopRidBagEntryDeletionTimer();
        completeOperation();
    }
}

Example 9 with OSessionStoragePerformanceStatistic

use of com.orientechnologies.orient.core.storage.impl.local.statistic.OSessionStoragePerformanceStatistic in project orientdb by orientechnologies.

the class OSBTreeBonsaiLocal method firstKey.

@Override
public K firstKey() {
    final OSessionStoragePerformanceStatistic statistic = performanceStatisticManager.getSessionPerformanceStatistic();
    startOperation();
    if (statistic != null)
        statistic.startRidBagEntryReadTimer();
    try {
        atomicOperationsManager.acquireReadLock(this);
        try {
            final Lock lock = FILE_LOCK_MANAGER.acquireSharedLock(fileId);
            try {
                LinkedList<PagePathItemUnit> path = new LinkedList<PagePathItemUnit>();
                OBonsaiBucketPointer bucketPointer = rootBucketPointer;
                OAtomicOperation atomicOperation = atomicOperationsManager.getCurrentOperation();
                OCacheEntry cacheEntry = loadPage(atomicOperation, fileId, rootBucketPointer.getPageIndex(), false);
                int itemIndex = 0;
                cacheEntry.acquireSharedLock();
                try {
                    OSBTreeBonsaiBucket<K, V> bucket = new OSBTreeBonsaiBucket<K, V>(cacheEntry, bucketPointer.getPageOffset(), keySerializer, valueSerializer, getChanges(atomicOperation, cacheEntry), this);
                    while (true) {
                        if (bucket.isLeaf()) {
                            if (bucket.isEmpty()) {
                                if (path.isEmpty()) {
                                    return null;
                                } else {
                                    PagePathItemUnit pagePathItemUnit = path.removeLast();
                                    bucketPointer = pagePathItemUnit.bucketPointer;
                                    itemIndex = pagePathItemUnit.itemIndex + 1;
                                }
                            } else {
                                return bucket.getKey(0);
                            }
                        } else {
                            if (bucket.isEmpty() || itemIndex > bucket.size()) {
                                if (path.isEmpty()) {
                                    return null;
                                } else {
                                    PagePathItemUnit pagePathItemUnit = path.removeLast();
                                    bucketPointer = pagePathItemUnit.bucketPointer;
                                    itemIndex = pagePathItemUnit.itemIndex + 1;
                                }
                            } else {
                                path.add(new PagePathItemUnit(bucketPointer, itemIndex));
                                if (itemIndex < bucket.size()) {
                                    OSBTreeBonsaiBucket.SBTreeEntry<K, V> entry = bucket.getEntry(itemIndex);
                                    bucketPointer = entry.leftChild;
                                } else {
                                    OSBTreeBonsaiBucket.SBTreeEntry<K, V> entry = bucket.getEntry(itemIndex - 1);
                                    bucketPointer = entry.rightChild;
                                }
                                itemIndex = 0;
                            }
                        }
                        cacheEntry.releaseSharedLock();
                        releasePage(atomicOperation, cacheEntry);
                        cacheEntry = loadPage(atomicOperation, fileId, bucketPointer.getPageIndex(), false);
                        cacheEntry.acquireSharedLock();
                        bucket = new OSBTreeBonsaiBucket<K, V>(cacheEntry, bucketPointer.getPageOffset(), keySerializer, valueSerializer, getChanges(atomicOperation, cacheEntry), this);
                    }
                } finally {
                    cacheEntry.releaseSharedLock();
                    releasePage(atomicOperation, cacheEntry);
                }
            } finally {
                lock.unlock();
            }
        } catch (IOException e) {
            throw OException.wrapException(new OSBTreeBonsaiLocalException("Error during finding first key in sbtree [" + getName() + "]", this), e);
        } finally {
            atomicOperationsManager.releaseReadLock(this);
        }
    } finally {
        if (statistic != null)
            statistic.stopRidBagEntryReadTimer(1);
        completeOperation();
    }
}

Example 10 with OSessionStoragePerformanceStatistic

use of com.orientechnologies.orient.core.storage.impl.local.statistic.OSessionStoragePerformanceStatistic 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();
    }
}