@Override public void setPage(ICachedPage page) { this.page = page; this.buf = page.getBuffer(); }
@Override public void get(ITreeIndexMetadataFrame frame, IValueReference key, IPointable value) throws HyracksDataException { ICachedPage page = pinPage(); page.acquireReadLatch(); try { frame.setPage(page); frame.get(key, value); } finally { page.releaseReadLatch(); unpinPage(page); } }
private void fetchNextLeafPage(int nextLeafPage) throws HyracksDataException { do { ICachedPage nextLeaf = bufferCache.pin(BufferedFileHandle.getDiskPageId(fileId, nextLeafPage), false); if (exclusiveLatchNodes) { nextLeaf.acquireWriteLatch(); page.releaseWriteLatch(isPageDirty); } else { nextLeaf.acquireReadLatch(); page.releaseReadLatch(); } bufferCache.unpin(page); page = nextLeaf; isPageDirty = false; frame.setPage(page); nextLeafPage = frame.getNextLeaf(); } while (frame.getTupleCount() == 0 && nextLeafPage > 0); }
protected void releasePage() throws HyracksDataException { if (exclusiveLatchNodes) { page.releaseWriteLatch(isPageDirty); } else { page.releaseReadLatch(); } bufferCache.unpin(page); }
protected ICachedPage acquirePage(int pageId) throws HyracksDataException { ICachedPage nextPage = bufferCache.pin(BufferedFileHandle.getDiskPageId(fileId, pageId), false); if (exclusiveLatchNodes) { nextPage.acquireWriteLatch(); } else { nextPage.acquireReadLatch(); } return nextPage; } }
private void readBloomFilterMetaData() throws HyracksDataException { if (bufferCache.getNumPagesOfFile(fileId) == 0) { numPages = 0; numHashes = 0; numElements = 0; numBits = 0; version = DEFAULT_BLOOM_FILTER_VERSION; return; } ICachedPage metaPage = bufferCache.pin(BufferedFileHandle.getDiskPageId(fileId, METADATA_PAGE_ID), false); metaPage.acquireReadLatch(); try { numPages = metaPage.getBuffer().getInt(NUM_PAGES_OFFSET); numHashes = metaPage.getBuffer().getInt(NUM_HASHES_USED_OFFSET); numElements = metaPage.getBuffer().getLong(NUM_ELEMENTS_OFFSET); numBits = metaPage.getBuffer().getLong(NUM_BITS_OFFSET); version = metaPage.getBuffer().getInt(VERSION_OFFSET); } finally { metaPage.releaseReadLatch(); bufferCache.unpin(metaPage); } }
@Override public int takePage(ITreeIndexMetadataFrame metaFrame) throws HyracksDataException { confiscatedPage.acquireWriteLatch(); int freePage = IBufferCache.INVALID_PAGEID; try { if (nextPage > 0) { // sibling may have free pages ICachedPage nextNode = bufferCache.pin(BufferedFileHandle.getDiskPageId(fileId, nextPage), false); nextNode.acquireWriteLatch(); System.arraycopy(nextNode.getBuffer().array(), 0, confiscatedPage.getBuffer().array(), 0, nextNode.getBuffer().capacity()); nextNode.releaseWriteLatch(true); bufferCache.unpin(nextNode); confiscatedPage.releaseWriteLatch(false);
@Override public void setRootPageId(int rootPage) throws HyracksDataException { ITreeIndexMetadataFrame metaFrame = frameFactory.createFrame(); confiscatedPage.acquireWriteLatch(); try { metaFrame.setPage(confiscatedPage); metaFrame.setRootPageId(rootPage); } finally { confiscatedPage.releaseWriteLatch(false); } ready = true; }
parent.releaseReadLatch(); } else { parent.releaseWriteLatch(true); ICachedPage interiorNode = bufferCache .pin(BufferedFileHandle.getDiskPageId(getFileId(), pageId), false); interiorNode.acquireWriteLatch(); try { interiorNode.releaseWriteLatch(true); bufferCache.unpin(interiorNode); ctx.setOpRestarts(ctx.getOpRestarts() + 1); if (isReadLatched) { node.releaseReadLatch(); } else { node.releaseWriteLatch(true); node.releaseWriteLatch(true); bufferCache.unpin(node); if (node != null) { if (isReadLatched) { node.releaseReadLatch(); } else { node.releaseWriteLatch(true); if (node != null) { if (isReadLatched) {
@Override public void close(IPageWriteFailureCallback callback) throws HyracksDataException { if (ready) { IFIFOPageQueue queue = bufferCache.createFIFOQueue(); ITreeIndexMetadataFrame metaFrame = frameFactory.createFrame(); confiscatedPage.acquireWriteLatch(); try { metaFrame.setPage(confiscatedPage); metaFrame.setValid(true); } finally { confiscatedPage.releaseWriteLatch(false); } int finalMetaPage = getMaxPageId(metaFrame) + 1; confiscatedPage.setDiskPageId(BufferedFileHandle.getDiskPageId(fileId, finalMetaPage)); final ICompressedPageWriter compressedPageWriter = bufferCache.getCompressedPageWriter(fileId); compressedPageWriter.prepareWrite(confiscatedPage); // WARNING: flushing the metadata page should be done after releasing the write latch; otherwise, the page // won't be flushed to disk because it won't be dirty until the write latch has been released. queue.put(confiscatedPage, callback); bufferCache.finishQueue(); compressedPageWriter.endWriting(); metadataPage = getMetadataPageId(); ready = false; } else if (confiscatedPage != null) { bufferCache.returnPage(confiscatedPage, false); } confiscatedPage = null; }
@Override public void resizePage(ICachedPage cPage, int multiplier, IExtraPageBlockHelper extraPageBlockHelper) { ByteBuffer oldBuffer = cPage.getBuffer(); int origMultiplier = cPage.getFrameSizeMultiplier(); if (origMultiplier == multiplier) {
@Override public void doDestroy() throws HyracksDataException { if (readLatched) { page.releaseReadLatch(); bufferCache.unpin(page); readLatched = false; } tupleIndex = 0; tupleIndexInc = 0; page = null; pathList = null; }
protected ICachedPage acquireNextPage() throws HyracksDataException { ICachedPage nextPage = bufferCache.pin(BufferedFileHandle.getDiskPageId(fileId, currentPageId), false); nextPage.acquireReadLatch(); return nextPage; } }
private void persistFrontiers(int level, int rightPage) throws HyracksDataException { if (level >= nodeFrontiers.size()) { rootPage = nodeFrontiers.get(level - 1).pageId; releasedLatches = true; return; } if (level < 1) { ICachedPage lastLeaf = nodeFrontiers.get(level).page; int lastLeafPage = nodeFrontiers.get(level).pageId; lastLeaf.setDiskPageId(BufferedFileHandle.getDiskPageId(getFileId(), nodeFrontiers.get(level).pageId)); putInQueue(lastLeaf); nodeFrontiers.get(level).page = null; persistFrontiers(level + 1, lastLeafPage); return; } NodeFrontier frontier = nodeFrontiers.get(level); interiorFrame.setPage(frontier.page); //just finalize = the layer right above the leaves has correct righthand pointers already if (rightPage < 0) { throw new HyracksDataException( "Error in index creation. Internal node appears to have no rightmost guide"); } ((IBTreeInteriorFrame) interiorFrame).setRightmostChildPageId(rightPage); int finalPageId = freePageManager.takePage(metaFrame); frontier.page.setDiskPageId(BufferedFileHandle.getDiskPageId(getFileId(), finalPageId)); putInQueue(frontier.page); frontier.pageId = finalPageId; persistFrontiers(level + 1, finalPageId); }
private void delete(ITupleReference tuple, RTreeOpContext ctx) throws HyracksDataException { ctx.reset(); ctx.setTuple(tuple); ctx.getSplitKey().reset(); ctx.getSplitKey().getLeftTuple().setFieldCount(cmpFactories.length); // We delete the first matching tuple (including the payload data). // We don't update the MBRs of the parents after deleting the record. int tupleIndex = findTupleToDelete(ctx); if (tupleIndex != -1) { try { deleteTuple(tupleIndex, ctx); } finally { ctx.getLeafFrame().getPage().releaseWriteLatch(true); bufferCache.unpin(ctx.getLeafFrame().getPage()); } } }
protected void handleException() { // Unlatch and unpin pages that weren't in the queue to avoid leaking memory. compressedPageWriter.abort(); for (NodeFrontier nodeFrontier : nodeFrontiers) { ICachedPage frontierPage = nodeFrontier.page; if (frontierPage.confiscated()) { bufferCache.returnPage(frontierPage, false); } } for (ICachedPage pageToDiscard : pagesToWrite) { bufferCache.returnPage(pageToDiscard, false); } releasedLatches = true; }
int deltaPages = page.getFrameSizeMultiplier() - rightFrame.getPage().getFrameSizeMultiplier(); if (deltaPages > 0) { ((BTreeNSMLeafFrame) rightFrame).growCapacity(extraPageBlockHelper, bufferCache, deltaPages);
@Override public void releasePage(ITreeIndexMetadataFrame metaFrame, int freePageNum) throws HyracksDataException { ICachedPage metaPage = bufferCache.pin(BufferedFileHandle.getDiskPageId(fileId, getMetadataPageId()), false); metaPage.acquireWriteLatch(); try { metaFrame.setPage(metaPage); newNode.acquireWriteLatch(); try { int metaMaxPage = metaFrame.getMaxPage(); System.arraycopy(metaPage.getBuffer().array(), 0, newNode.getBuffer().array(), 0, metaPage.getBuffer().capacity()); metaFrame.init(); metaFrame.setNextMetadataPage(newPageNum); metaFrame.addFreePage(freePageNum); } finally { newNode.releaseWriteLatch(true); bufferCache.unpin(newNode); metaPage.releaseWriteLatch(true); bufferCache.unpin(metaPage);
@Override public void put(ITreeIndexMetadataFrame frame, IValueReference key, IValueReference value) throws HyracksDataException { if (confiscatedPage == null) { throw HyracksDataException.create(ErrorCode.ILLEGAL_WRITE_AFTER_FLUSH_ATTEMPT); } confiscatedPage.acquireWriteLatch(); try { frame.setPage(confiscatedPage); frame.put(key, value); } finally { confiscatedPage.releaseWriteLatch(false); } }
private boolean legacyContains(long[] hashes) throws HyracksDataException { for (int i = 0; i < numHashes; ++i) { long hash = Math.abs((hashes[0] + i * hashes[1]) % numBits); // we increment the page id by one, since the metadata page id of the filter is 0. ICachedPage page = bufferCache.pin(BufferedFileHandle.getDiskPageId(fileId, (int) (hash / numBitsPerPage) + 1), false); page.acquireReadLatch(); try { ByteBuffer buffer = page.getBuffer(); int byteIndex = (int) (hash % numBitsPerPage) >> 3; // divide by 8 byte b = buffer.get(byteIndex); int bitIndex = (int) (hash % numBitsPerPage) & 0x07; // mod 8 if (!((b & (1L << bitIndex)) != 0)) { return false; } } finally { page.releaseReadLatch(); bufferCache.unpin(page); } } return true; }