/** * @param grp Cache group. * @return Tree leaf IO. */ private static IOVersions<? extends AbstractDataLeafIO> leafIO(CacheGroupContext grp) { if (grp.mvccEnabled()) return grp.sharedGroup() ? MvccCacheIdAwareDataLeafIO.VERSIONS : MvccDataLeafIO.VERSIONS; return grp.sharedGroup() ? CacheIdAwareDataLeafIO.VERSIONS : DataLeafIO.VERSIONS; }
/** * @param grp Cache group. * @return Tree inner IO. */ private static IOVersions<? extends AbstractDataInnerIO> innerIO(CacheGroupContext grp) { if (grp.mvccEnabled()) return grp.sharedGroup() ? MvccCacheIdAwareDataInnerIO.VERSIONS : MvccDataInnerIO.VERSIONS; return grp.sharedGroup() ? CacheIdAwareDataInnerIO.VERSIONS : DataInnerIO.VERSIONS; }
/** {@inheritDoc} */ @Nullable @Override protected CacheMapHolder entriesMapIfExists(Integer cacheId) { return grp.sharedGroup() ? cacheMaps.get(cacheId) : singleCacheEntryMap; }
/** {@inheritDoc} */ @Override public long cacheSize(int cacheId) { if (grp.sharedGroup()) { AtomicLong size = cacheSizes.get(cacheId); return size != null ? (int)size.get() : 0; } return storageSize.get(); }
/** {@inheritDoc} */ @Override public int internalSize() { if (grp.sharedGroup()) { int size = 0; for (CacheMapHolder hld : cacheMaps.values()) size += hld.map.size(); return size; } return singleCacheEntryMap.map.size(); }
/** {@inheritDoc} */ @Override public Map<Integer, Long> cacheSizes() { if (!grp.sharedGroup()) return null; Map<Integer, Long> res = new HashMap<>(); for (Map.Entry<Integer, AtomicLong> e : cacheSizes.entrySet()) res.put(e.getKey(), e.getValue().longValue()); return res; }
/** {@inheritDoc} */ @Override public void updateSize(int cacheId, long delta) { storageSize.addAndGet(delta); if (grp.sharedGroup()) { AtomicLong size = cacheSizes.get(cacheId); if (size == null) { AtomicLong old = cacheSizes.putIfAbsent(cacheId, size = new AtomicLong()); if (old != null) size = old; } size.addAndGet(delta); } }
/** {@inheritDoc} */ @Override protected CacheMapHolder entriesMap(GridCacheContext cctx) { if (grp.sharedGroup()) return cacheMapHolder(cctx); return singleCacheEntryMap; }
/** {@inheritDoc} */ @Override protected void release(int sizeChange, CacheMapHolder hld, GridCacheEntryEx e) { if (grp.sharedGroup() && sizeChange != 0) hld.size.addAndGet(sizeChange); release0(sizeChange); }
/** * @param cacheId Cache ID. */ public void onCacheStopped(int cacheId) { if (!grp.sharedGroup()) return; for (int i = 0; i < locParts.length(); i++) { GridDhtLocalPartition part = locParts.get(i); if (part != null) part.onCacheStopped(cacheId); } }
/** * @param grpName Group name. * @return Found group or null. */ private CacheGroupContext findCacheGroup(String grpName) { return cacheGrps.values().stream() .filter(grp -> grp.sharedGroup() && grpName.equals(grp.name())) .findAny() .orElse(null); }
/** {@inheritDoc} */ @Override public int publicSize(int cacheId) { if (grp.sharedGroup()) { CacheMapHolder hld = cacheMaps.get(cacheId); return hld != null ? hld.size.get() : 0; } return getSize(state.get()); }
/** * @param cacheId Cache ID. * @param key Key. * @param ver Version. */ private void removeVersionedEntry(int cacheId, KeyCacheObject key, GridCacheVersion ver) { CacheMapHolder hld = grp.sharedGroup() ? cacheMaps.get(cacheId) : singleCacheEntryMap; GridCacheMapEntry entry = hld != null ? hld.map.get(key) : null; if (entry != null && entry.markObsoleteVersion(ver)) removeEntry(entry); }
/** * @param cacheId Cache ID. */ public void onCacheStopped(int cacheId) { assert grp.sharedGroup() : grp.cacheOrGroupName(); for (Iterator<RemovedEntryHolder> it = rmvQueue.iterator(); it.hasNext();) { RemovedEntryHolder e = it.next(); if (e.cacheId() == cacheId) it.remove(); } cacheMaps.remove(cacheId); }
/** * @return {@code True} if this is cache group for one of system caches. */ public boolean systemCache() { return !sharedGroup() && CU.isSystemCache(ccfg.getName()); }
/** * @return Cache context if group contains single cache. */ public GridCacheContext singleCacheContext() { List<GridCacheContext> caches = this.caches; assert !sharedGroup() && caches.size() == 1 : "stopping=" + ctx.kernalContext().isStopping() + ", groupName=" + ccfg.getGroupName() + ", caches=" + caches; return caches.get(0); }
/** * @param dataRow Data row. * @param cacheId Cache ID. */ private <T extends DataRow> T initDataRow(T dataRow, int cacheId) { if (dataRow.cacheId() == CU.UNDEFINED_CACHE_ID && grp.sharedGroup()) dataRow.cacheId(cacheId); return dataRow; } }
/** {@inheritDoc} */ @Override public void incrementPublicSize(@Nullable CacheMapHolder hld, GridCacheEntryEx e) { if (grp.sharedGroup()) { if (hld == null) hld = cacheMapHolder(e.context()); hld.size.incrementAndGet(); } while (true) { long state = this.state.get(); if (this.state.compareAndSet(state, setSize(state, getSize(state) + 1))) return; } }
/** {@inheritDoc} */ @Override public void invoke(GridCacheContext cctx, KeyCacheObject key, OffheapInvokeClosure c) throws IgniteCheckedException { int cacheId = grp.sharedGroup() ? cctx.cacheId() : CU.UNDEFINED_CACHE_ID; invoke0(cctx, new SearchRow(cacheId, key), c); }
/** {@inheritDoc} */ @Override public void remove(GridCacheContext cctx, KeyCacheObject key, int partId) throws IgniteCheckedException { if (!busyLock.enterBusy()) throw new NodeStoppingException("Operation has been cancelled (node is stopping)."); try { int cacheId = grp.sharedGroup() ? cctx.cacheId() : CU.UNDEFINED_CACHE_ID; assert cctx.shared().database().checkpointLockIsHeldByThread(); CacheDataRow oldRow = dataTree.remove(new SearchRow(cacheId, key)); finishRemove(cctx, key, oldRow); } finally { busyLock.leaveBusy(); } }