/** * Update page * * @param link Link. * @throws IgniteCheckedException On error. */ private void touch(long link) throws IgniteCheckedException { PageMemory mem = grpCtx.dataRegion().pageMemory(); int grpId = grpCtx.groupId(); final long pageId = PageIdUtils.pageId(link); final long page = mem.acquirePage(grpId, pageId); try { // Touch page timestamp mem.readLock(grpId, pageId, page); mem.readUnlock(grpId, pageId, page); } finally { mem.releasePage(grpId, pageId, page); } } }
cntrsPageId = pageMem.allocatePage(grpId, partId, PageIdAllocator.FLAG_DATA); final long curPage = pageMem.acquirePage(grpId, curId); final long curAddr = pageMem.writeLock(grpId, curId, curPage); partCntrIo = PagePartitionCountersIO.VERSIONS.latest(); partCntrIo.initNewPage(curAddr, curId, pageMem.realPageSize(grpId)); written += partCntrIo.writeCacheSizes(pageMem.realPageSize(grpId), curAddr, data, written); nextId = pageMem.allocatePage(grpId, partId, PageIdAllocator.FLAG_DATA); partCntrIo.setNextCountersPageId(curAddr, nextId); pageMem.writeUnlock(grpId, curId, curPage, Boolean.TRUE, true); pageMem.releasePage(grpId, curId, curPage);
/** * @throws Exception If failed. */ @Test public void testLoadedPagesCount() throws Exception { PageMemory mem = memory(); mem.start(); int expPages = MAX_MEMORY_SIZE / mem.systemPageSize(); try { for (int i = 0; i < expPages * 2; i++) allocatePage(mem); } catch (IgniteOutOfMemoryException e) { e.printStackTrace(); // Expected. assertEquals(mem.loadedPages(), expPages); } finally { mem.stop(true); } }
/** {@inheritDoc} */ @Override public long getOffheapUsedSize() { if (!metricsEnabled) return 0; return pageMem.loadedPages() * pageMem.systemPageSize(); }
/** {@inheritDoc} */ @Override public long getTotalAllocatedSize() { assert pageMem != null; return getTotalAllocatedPages() * (persistenceEnabled ? pageMem.pageSize() : pageMem.systemPageSize()); }
false); pageMem.start(); pageId = pageMem.allocatePage(CACHE_ID, 1, PageIdAllocator.FLAG_DATA); page = pageMem.acquirePage(CACHE_ID, pageId); long pageAddr = pageMem.readLock(CACHE_ID, pageId, page); pageMem.releasePage(CACHE_ID, pageId, page); pageMem.stop(true);
mem.start(); long pageApsPtr = mem.acquirePage(id.groupId(), id.pageId()); try { long pageAddr = mem.writeLock(id.groupId(), id.pageId(), pageApsPtr); PAGE_IO.initNewPage(pageAddr, id.pageId(), mem.realPageSize(id.groupId())); mem.writeUnlock(id.groupId(), id.pageId(), pageApsPtr, null, true); mem.releasePage(id.groupId(), id.pageId(), pageApsPtr); long pageApsPtr = mem.acquirePage(id.groupId(), id.pageId()); try { long pageAddr = mem.writeLock(id.groupId(), id.pageId(), pageApsPtr); mem.writeUnlock(id.groupId(), id.pageId(), pageApsPtr, null, false); mem.readLock(id.groupId(), id.pageId(), pageApsPtr); mem.readUnlock(id.groupId(), id.pageId(), pageApsPtr); mem.releasePage(id.groupId(), id.pageId(), pageApsPtr); long pageApsPtr = mem.acquirePage(id.groupId(), id.pageId()); try { long pageAddr = mem.writeLock(id.groupId(), id.pageId(), pageApsPtr); mem.writeUnlock(id.groupId(), id.pageId(), pageApsPtr, null, false);
final long pageId = pageId(nextLink); final long page = pageMem.acquirePage(grpId, pageId); long pageAddr = pageMem.readLock(grpId, pageId, page); // Non-empty data page must not be recycled. DataPagePayload data = io.readPayload(pageAddr, itemId(nextLink), pageMem.pageSize()); ByteBuffer buf = pageMem.pageBuffer(pageAddr); pageMem.readUnlock(grpId, pageId, page); pageMem.releasePage(grpId, pageId, page);
PageMemory mem = memory(); mem.start(); long page = mem.acquirePage(fullId.groupId(), fullId.pageId()); mem.releasePage(fullId.groupId(), fullId.pageId(), page); FullPageId fullId = pages.get(i); long page = mem.acquirePage(fullId.groupId(), fullId.pageId()); mem.releasePage(fullId.groupId(), fullId.pageId(), page); mem.stop(true);
final long page = pageMemory.acquirePage(grp.groupId(), pageId); long pageAddr = pageMemory.readLock(grp.groupId(), pageId, page); try { assert PageIO.getType(pageAddr) != 0; pageMemory.readUnlock(grp.groupId(), pageId, page);
/** * @return Page ID of newly allocated page. * @throws IgniteCheckedException If failed. */ protected long allocatePageNoReuse() throws IgniteCheckedException { return pageMem.allocatePage(grpId, PageIdAllocator.INDEX_PARTITION, FLAG_IDX); }
long rmtPage = pageMem.acquirePage(fullPageId.groupId(), fullPageId.pageId()); long rmtPageAddr = pageMem.readLockForce(fullPageId.groupId(), fullPageId.pageId(), rmtPage); pageMem.readUnlock(fullPageId.groupId(), fullPageId.pageId(), rmtPage); pageMem.releasePage(fullPageId.groupId(), fullPageId.pageId(), rmtPage);
IoStatisticsHolder statHolder ) throws IgniteCheckedException { long page = pageMem.acquirePage(cacheId, pageId, statHolder); try { long pageAddr = readLock(pageMem, cacheId, pageId, page, lsnr); pageMem.releasePage(cacheId, pageId, page); ) throws IgniteCheckedException { boolean releaseAfterWrite = true; long page = pageMem.acquirePage(grpId, pageId, statHolder); try { long pageAddr = writeLock(pageMem, grpId, pageId, page, lsnr, false); pageMem.releasePage(grpId, pageId, page);
/** * @throws Exception If failed. */ @Test public void testPageHandleDeallocation() throws Exception { PageMemory mem = memory(); mem.start(); try { int pages = 3 * 1024 * 1024 / (8 * 1024); Collection<FullPageId> handles = new HashSet<>(); for (int i = 0; i < pages; i++) handles.add(allocatePage(mem)); for (FullPageId fullId : handles) mem.freePage(fullId.groupId(), fullId.pageId()); for (int i = 0; i < pages; i++) assertFalse(handles.add(allocatePage(mem))); } finally { mem.stop(true); } }
/** * @param mem Page memory. * @param pageId Page ID. * @param page Page pointer. * @param expVal Expected value. */ private void readPage(PageMemory mem, long pageId, long page, int expVal) { expVal &= 0xFF; long pageAddr = mem.readLock(-1, pageId, page); assert pageAddr != 0; try { for (int i = PageIO.COMMON_HEADER_END; i < PAGE_SIZE; i++) { int val = PageUtils.getByte(pageAddr, i) & 0xFF; assertEquals("Unexpected value at position: " + i, expVal, val); } } finally { mem.readUnlock(-1, pageId, page); } }
/** * */ private void startDataRegions() { for (DataRegion region : dataRegionMap.values()) { region.pageMemory().start(); region.evictionTracker().start(); } }
/** */ private void readMetastore() throws IgniteCheckedException { try { CheckpointStatus status = readCheckpointStatus(); checkpointReadLock(); try { dataRegion(METASTORE_DATA_REGION_NAME).pageMemory().start(); performBinaryMemoryRestore(status, onlyMetastorageGroup(), physicalRecords(), false); metaStorage = createMetastorage(true); applyLogicalUpdates(status, onlyMetastorageGroup(), onlyMetastorageRecords(), false); fillWalDisabledGroups(); notifyMetastorageReadyForRead(); } finally { metaStorage = null; dataRegion(METASTORE_DATA_REGION_NAME).pageMemory().stop(false); cctx.pageStore().cleanupPageStoreIfMatch(new Predicate<Integer>() { @Override public boolean test(Integer grpId) { return MetaStorage.METASTORAGE_CACHE_ID == grpId; } }, false); checkpointReadUnlock(); } } catch (StorageException e) { cctx.kernalContext().failure().process(new FailureContext(FailureType.CRITICAL_ERROR, e)); throw new IgniteCheckedException(e); } }
/** {@inheritDoc} */ @Override protected void afterTest() throws Exception { super.afterTest(); if (pageMem != null) pageMem.stop(true); pageMem = null; }
/** * @param pageId Page ID. * @param statHolder Statistics holder to track IO operations. * @return Page absolute pointer. * @throws IgniteCheckedException If failed. */ protected final long acquirePage(long pageId, IoStatisticsHolder statHolder) throws IgniteCheckedException { assert PageIdUtils.flag(pageId) == FLAG_IDX && PageIdUtils.partId(pageId) == INDEX_PARTITION || PageIdUtils.flag(pageId) == FLAG_DATA && PageIdUtils.partId(pageId) <= MAX_PARTITION_ID : U.hexLong(pageId) + " flag=" + PageIdUtils.flag(pageId) + " part=" + PageIdUtils.partId(pageId); return pageMem.acquirePage(grpId, pageId, statHolder); }
/** * @param pageId Page ID. * @param page Page pointer. */ protected final void releasePage(long pageId, long page) { pageMem.releasePage(grpId, pageId, page); }