Examples with PagePartitionMetaIOV3 org.apache.ignite.internal.processors.cache.persistence.tree.io.PagePartitionMetaIOV3 used on opensource projects

Example 1 with PagePartitionMetaIOV3

use of org.apache.ignite.internal.processors.cache.persistence.tree.io.PagePartitionMetaIOV3 in project ignite by apache.

the class GridCacheOffheapManager method saveStoreMetadata.

/**
 * @param store Store to save metadata.
 * @throws IgniteCheckedException If failed.
 */
private void saveStoreMetadata(CacheDataStore store, Context ctx, boolean beforeDestroy, boolean needSnapshot) throws IgniteCheckedException {
    RowStore rowStore0 = store.rowStore();
    if (rowStore0 != null && (partitionStatesRestored || grp.isLocal())) {
        ((CacheFreeList) rowStore0.freeList()).saveMetadata(grp.statisticsHolderData());
        PartitionMetaStorage<SimpleDataRow> partStore = store.partStorage();
        long updCntr = store.updateCounter();
        long size = store.fullSize();
        long rmvId = globalRemoveId().get();
        byte[] updCntrsBytes = store.partUpdateCounter().getBytes();
        PageMemoryEx pageMem = (PageMemoryEx) grp.dataRegion().pageMemory();
        IgniteWriteAheadLogManager wal = this.ctx.wal();
        GridEncryptionManager encMgr = this.ctx.kernalContext().encryption();
        if (size > 0 || updCntr > 0 || !store.partUpdateCounter().sequential() || (grp.config().isEncryptionEnabled() && encMgr.getEncryptionState(grp.groupId(), store.partId()) > 0)) {
            GridDhtPartitionState state = null;
            // localPartition will not acquire writeLock here because create=false.
            GridDhtLocalPartition part = null;
            if (!grp.isLocal()) {
                if (beforeDestroy)
                    state = GridDhtPartitionState.EVICTED;
                else {
                    part = getPartition(store);
                    if (part != null && part.state() != GridDhtPartitionState.EVICTED)
                        state = part.state();
                }
                // Do not save meta for evicted partitions on next checkpoints.
                if (state == null)
                    return;
            }
            int grpId = grp.groupId();
            long partMetaId = pageMem.partitionMetaPageId(grpId, store.partId());
            long partMetaPage = pageMem.acquirePage(grpId, partMetaId);
            try {
                long partMetaPageAddr = pageMem.writeLock(grpId, partMetaId, partMetaPage);
                if (partMetaPageAddr == 0L) {
                    U.warn(log, "Failed to acquire write lock for meta page [metaPage=" + partMetaPage + ", beforeDestroy=" + beforeDestroy + ", size=" + size + ", updCntr=" + updCntr + ", state=" + state + ']');
                    return;
                }
                boolean changed = false;
                try {
                    PagePartitionMetaIOV3 io = PageIO.getPageIO(partMetaPageAddr);
                    long link = io.getGapsLink(partMetaPageAddr);
                    if (updCntrsBytes == null && link != 0) {
                        partStore.removeDataRowByLink(link, grp.statisticsHolderData());
                        io.setGapsLink(partMetaPageAddr, (link = 0));
                        changed = true;
                    } else if (updCntrsBytes != null && link == 0) {
                        SimpleDataRow row = new SimpleDataRow(store.partId(), updCntrsBytes);
                        partStore.insertDataRow(row, grp.statisticsHolderData());
                        io.setGapsLink(partMetaPageAddr, (link = row.link()));
                        changed = true;
                    } else if (updCntrsBytes != null && link != 0) {
                        byte[] prev = partStore.readRow(link);
                        assert prev != null : "Read null gaps using link=" + link;
                        if (!Arrays.equals(prev, updCntrsBytes)) {
                            partStore.removeDataRowByLink(link, grp.statisticsHolderData());
                            SimpleDataRow row = new SimpleDataRow(store.partId(), updCntrsBytes);
                            partStore.insertDataRow(row, grp.statisticsHolderData());
                            io.setGapsLink(partMetaPageAddr, (link = row.link()));
                            changed = true;
                        }
                    }
                    if (changed)
                        partStore.saveMetadata(grp.statisticsHolderData());
                    changed |= io.setUpdateCounter(partMetaPageAddr, updCntr);
                    changed |= io.setGlobalRemoveId(partMetaPageAddr, rmvId);
                    changed |= io.setSize(partMetaPageAddr, size);
                    int encryptIdx = 0;
                    int encryptCnt = 0;
                    if (grp.config().isEncryptionEnabled()) {
                        long reencryptState = encMgr.getEncryptionState(grpId, store.partId());
                        if (reencryptState != 0) {
                            encryptIdx = ReencryptStateUtils.pageIndex(reencryptState);
                            encryptCnt = ReencryptStateUtils.pageCount(reencryptState);
                            if (encryptIdx == encryptCnt) {
                                encMgr.setEncryptionState(grp, store.partId(), 0, 0);
                                encryptIdx = encryptCnt = 0;
                            }
                            changed |= io.setEncryptedPageIndex(partMetaPageAddr, encryptIdx);
                            changed |= io.setEncryptedPageCount(partMetaPageAddr, encryptCnt);
                        }
                    }
                    if (state != null)
                        changed |= io.setPartitionState(partMetaPageAddr, (byte) state.ordinal());
                    else
                        assert grp.isLocal() : grp.cacheOrGroupName();
                    long cntrsPageId;
                    if (grp.sharedGroup()) {
                        long initCntrPageId = io.getCountersPageId(partMetaPageAddr);
                        Map<Integer, Long> newSizes = store.cacheSizes();
                        Map<Integer, Long> prevSizes = readSharedGroupCacheSizes(pageMem, grpId, initCntrPageId);
                        if (prevSizes != null && prevSizes.equals(newSizes))
                            // Preventing modification of sizes pages for store
                            cntrsPageId = initCntrPageId;
                        else {
                            cntrsPageId = writeSharedGroupCacheSizes(pageMem, grpId, initCntrPageId, store.partId(), newSizes);
                            if (initCntrPageId == 0 && cntrsPageId != 0) {
                                io.setCountersPageId(partMetaPageAddr, cntrsPageId);
                                changed = true;
                            }
                        }
                    } else
                        cntrsPageId = 0L;
                    int pageCnt;
                    if (needSnapshot) {
                        pageCnt = this.ctx.pageStore().pages(grpId, store.partId());
                        io.setCandidatePageCount(partMetaPageAddr, size == 0 ? 0 : pageCnt);
                        if (state == OWNING) {
                            assert part != null;
                            if (!addPartition(part, ctx.partitionStatMap(), partMetaPageAddr, io, grpId, store.partId(), this.ctx.pageStore().pages(grpId, store.partId()), store.fullSize()))
                                U.warn(log, "Partition was concurrently evicted grpId=" + grpId + ", partitionId=" + part.id());
                        } else if (state == MOVING || state == RENTING) {
                            if (ctx.partitionStatMap().forceSkipIndexPartition(grpId)) {
                                if (log.isInfoEnabled())
                                    log.info("Will not include SQL indexes to snapshot because there is " + "a partition not in " + OWNING + " state [grp=" + grp.cacheOrGroupName() + ", partId=" + store.partId() + ", state=" + state + ']');
                            }
                        }
                        changed = true;
                    } else
                        pageCnt = io.getCandidatePageCount(partMetaPageAddr);
                    if (changed && isWalDeltaRecordNeeded(pageMem, grpId, partMetaId, partMetaPage, wal, null))
                        wal.log(new MetaPageUpdatePartitionDataRecordV3(grpId, partMetaId, updCntr, rmvId, // TODO: Partition size may be long
                        (int) size, cntrsPageId, state == null ? -1 : (byte) state.ordinal(), pageCnt, link, encryptIdx, encryptCnt));
                    if (changed) {
                        partStore.saveMetadata(grp.statisticsHolderData());
                        io.setPartitionMetaStoreReuseListRoot(partMetaPageAddr, partStore.metaPageId());
                    }
                } finally {
                    pageMem.writeUnlock(grpId, partMetaId, partMetaPage, null, changed);
                }
            } finally {
                pageMem.releasePage(grpId, partMetaId, partMetaPage);
            }
        } else if (needSnapshot)
            tryAddEmptyPartitionToSnapshot(store, ctx);
    } else if (needSnapshot)
        tryAddEmptyPartitionToSnapshot(store, ctx);
}

Example 2 with PagePartitionMetaIOV3

use of org.apache.ignite.internal.processors.cache.persistence.tree.io.PagePartitionMetaIOV3 in project ignite by apache.

the class MetaPageUpdatePartitionDataRecordV3 method applyDelta.

/**
 * {@inheritDoc}
 */
@Override
public void applyDelta(PageMemory pageMem, long pageAddr) throws IgniteCheckedException {
    super.applyDelta(pageMem, pageAddr);
    PagePartitionMetaIOV3 io = (PagePartitionMetaIOV3) PagePartitionMetaIO.VERSIONS.forPage(pageAddr);
    io.setEncryptedPageIndex(pageAddr, encryptedPageIdx);
    io.setEncryptedPageCount(pageAddr, encryptedPageCnt);
}

Example 3 with PagePartitionMetaIOV3

use of org.apache.ignite.internal.processors.cache.persistence.tree.io.PagePartitionMetaIOV3 in project ignite by apache.

the class CachePartitionDefragmentationManager method copyCacheMetadata.

/**
 */
private void copyCacheMetadata(PartitionContext partCtx) throws IgniteCheckedException {
    // Same for all page memories. Why does it need to be in PageMemory?
    long partMetaPageId = partCtx.cachePageMemory.partitionMetaPageId(partCtx.grpId, partCtx.partId);
    long oldPartMetaPage = partCtx.cachePageMemory.acquirePage(partCtx.grpId, partMetaPageId);
    try {
        long oldPartMetaPageAddr = partCtx.cachePageMemory.readLock(partCtx.grpId, partMetaPageId, oldPartMetaPage);
        try {
            PagePartitionMetaIO oldPartMetaIo = PageIO.getPageIO(oldPartMetaPageAddr);
            // Newer meta versions may contain new data that we don't copy during defragmentation.
            assert Arrays.asList(1, 2, 3).contains(oldPartMetaIo.getVersion()) : "IO version " + oldPartMetaIo.getVersion() + " is not supported by current defragmentation algorithm." + " Please implement copying of all data added in new version.";
            long newPartMetaPage = partCtx.partPageMemory.acquirePage(partCtx.grpId, partMetaPageId);
            try {
                long newPartMetaPageAddr = partCtx.partPageMemory.writeLock(partCtx.grpId, partMetaPageId, newPartMetaPage);
                try {
                    PagePartitionMetaIOV3 newPartMetaIo = PageIO.getPageIO(newPartMetaPageAddr);
                    // Copy partition state.
                    byte partState = oldPartMetaIo.getPartitionState(oldPartMetaPageAddr);
                    newPartMetaIo.setPartitionState(newPartMetaPageAddr, partState);
                    // Copy cache size for single cache group.
                    long size = oldPartMetaIo.getSize(oldPartMetaPageAddr);
                    newPartMetaIo.setSize(newPartMetaPageAddr, size);
                    // Copy update counter value.
                    long updateCntr = oldPartMetaIo.getUpdateCounter(oldPartMetaPageAddr);
                    newPartMetaIo.setUpdateCounter(newPartMetaPageAddr, updateCntr);
                    // Copy global remove Id.
                    long rmvId = oldPartMetaIo.getGlobalRemoveId(oldPartMetaPageAddr);
                    newPartMetaIo.setGlobalRemoveId(newPartMetaPageAddr, rmvId);
                    long reuseListRoot = oldPartMetaIo.getPartitionMetaStoreReuseListRoot(oldPartMetaPageAddr);
                    newPartMetaIo.setPartitionMetaStoreReuseListRoot(newPartMetaPageAddr, reuseListRoot);
                    // Copy cache sizes for shared cache group.
                    long oldCountersPageId = oldPartMetaIo.getCountersPageId(oldPartMetaPageAddr);
                    if (oldCountersPageId != 0L) {
                        Map<Integer, Long> sizes = GridCacheOffheapManager.readSharedGroupCacheSizes(partCtx.cachePageMemory, partCtx.grpId, oldCountersPageId);
                        long newCountersPageId = GridCacheOffheapManager.writeSharedGroupCacheSizes(partCtx.partPageMemory, partCtx.grpId, 0L, partCtx.partId, sizes);
                        newPartMetaIo.setCountersPageId(newPartMetaPageAddr, newCountersPageId);
                    }
                    // Copy counter gaps.
                    long oldGapsLink = oldPartMetaIo.getGapsLink(oldPartMetaPageAddr);
                    if (oldGapsLink != 0L) {
                        byte[] gapsBytes = partCtx.oldCacheDataStore.partStorage().readRow(oldGapsLink);
                        SimpleDataRow gapsDataRow = new SimpleDataRow(partCtx.partId, gapsBytes);
                        partCtx.newCacheDataStore.partStorage().insertDataRow(gapsDataRow, IoStatisticsHolderNoOp.INSTANCE);
                        newPartMetaIo.setGapsLink(newPartMetaPageAddr, gapsDataRow.link());
                        newPartMetaIo.setPartitionMetaStoreReuseListRoot(newPartMetaPageAddr, oldPartMetaIo.getPartitionMetaStoreReuseListRoot(oldPartMetaPageAddr));
                    }
                    // Encryption stuff.
                    newPartMetaIo.setEncryptedPageCount(newPartMetaPageAddr, 0);
                    newPartMetaIo.setEncryptedPageIndex(newPartMetaPageAddr, 0);
                } finally {
                    partCtx.partPageMemory.writeUnlock(partCtx.grpId, partMetaPageId, newPartMetaPage, null, true);
                }
            } finally {
                partCtx.partPageMemory.releasePage(partCtx.grpId, partMetaPageId, newPartMetaPage);
            }
        } finally {
            partCtx.cachePageMemory.readUnlock(partCtx.grpId, partMetaPageId, oldPartMetaPage);
        }
    } finally {
        partCtx.cachePageMemory.releasePage(partCtx.grpId, partMetaPageId, oldPartMetaPage);
    }
}