VladRodionov commented on code in PR #8231: URL: https://github.com/apache/hbase/pull/8231#discussion_r3238229477
########## hbase-server/src/main/java/org/apache/hadoop/hbase/io/hfile/cache/TopologyBackedCacheAccessService.java: ########## @@ -0,0 +1,476 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hbase.io.hfile.cache; + +import java.util.Objects; +import java.util.Optional; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hbase.io.hfile.BlockCacheKey; +import org.apache.hadoop.hbase.io.hfile.BlockType; +import org.apache.hadoop.hbase.io.hfile.CacheStats; +import org.apache.hadoop.hbase.io.hfile.Cacheable; +import org.apache.hadoop.hbase.io.hfile.HFileBlock; +import org.apache.yetus.audience.InterfaceAudience; + +/** + * {@link CacheAccessService} implementation backed by {@link CacheTopology} and {@link CacheEngine} + * instances. + * <p> + * This implementation connects the cache access layer to the topology, policy, and engine + * abstractions. {@link CachePlacementAdmissionPolicy} decides whether a block should be admitted, + * where it should be placed, which representation should be used, and whether a hit should trigger + * promotion. {@link CacheTopology} provides tier structure, engine lookup, aggregate statistics, + * and topology-specific promotion mechanics. {@link CacheEngine} performs the actual storage + * operations. + * </p> + * <p> + * This class is the topology-backed counterpart to {@link BlockCacheBackedCacheAccessService}. The + * block-cache-backed implementation is useful for incremental migration with no behavior change. + * This implementation is useful once callers are ready to exercise the new topology and engine + * abstractions directly through {@link CacheAccessService}. + * </p> + * <p> + * Representation conversion is not performed by this initial implementation. This preserves current + * behavior while leaving room for future packed/unpacked or engine-default representation handling. + * </p> + */ [email protected] +public class TopologyBackedCacheAccessService implements CacheAccessService { + + private final CacheTopology topology; + private final CachePlacementAdmissionPolicy policy; + private final CacheTopologyView topologyView; + + /** + * Creates a topology-backed cache access service. + * @param topology cache topology used for tier structure, engine lookup, and promotion mechanics + * @param policy placement and admission policy used for cache access decisions + */ + public TopologyBackedCacheAccessService(CacheTopology topology, + CachePlacementAdmissionPolicy policy) { + this.topology = Objects.requireNonNull(topology, "topology must not be null"); + this.policy = Objects.requireNonNull(policy, "policy must not be null"); + this.topologyView = + Objects.requireNonNull(topology.getView(), "topology view must not be null"); + } + + /** + * Returns the topology used by this service. + * <p> + * This accessor is intended for tests, diagnostics, and transitional wiring. HBase read/write + * path callers should use {@link CacheAccessService} methods instead of accessing topology + * directly. + * </p> + * @return cache topology + */ + public CacheTopology getTopology() { + return topology; + } + + /** + * Returns the placement/admission policy used by this service. + * @return placement/admission policy + */ + public CachePlacementAdmissionPolicy getPolicy() { + return policy; + } + + /** + * Returns the read-only topology view used by policy calls. + * @return read-only topology view + */ + public CacheTopologyView getTopologyView() { + return topologyView; + } + + /** + * Returns a human-readable service name. + * @return service name + */ + @Override + public String getName() { + return topology.getName(); + } + + /** + * Fetches a block by checking topology tiers in lookup order. + * <p> + * The lookup order is defined by {@link CacheTopology#getTiers()}. On a cache hit, this method + * asks the configured {@link CachePlacementAdmissionPolicy} whether the block should be promoted. + * If promotion is requested and the target tier exists, promotion mechanics are delegated to + * {@link CacheTopology#promote(BlockCacheKey, Cacheable, CacheEngine, CacheEngine)}. + * </p> + * @param cacheKey block to fetch + * @param context cache request context + * @return cached block, or {@code null} if not present in any tier + */ + @Override + public Cacheable getBlock(BlockCacheKey cacheKey, CacheRequestContext context) { + Objects.requireNonNull(cacheKey, "cacheKey must not be null"); + Objects.requireNonNull(context, "context must not be null"); + + for (CacheTier tier : topology.getTiers()) { + Optional<CacheEngine> engine = topology.getEngine(tier); + if (engine.isEmpty()) { + continue; + } + + Cacheable block = getBlockFromEngine(engine.get(), cacheKey, context); + if (block != null) { + maybePromote(cacheKey, block, tier, engine.get(), context); + return block; + } + } + + return null; + } + + /** + * Adds a block to the cache using policy-selected target tiers. + * <p> + * This method first asks the configured policy whether the block should be admitted. If admitted, + * the policy selects the target tier or tiers. The block is then inserted into each selected + * engine using {@link CacheEngine#cacheBlock(BlockCacheKey, Cacheable, boolean, boolean)}. + * </p> + * <p> + * The policy's representation decision is intentionally not applied in this initial + * implementation. The current block object is passed through unchanged. + * </p> + * @param cacheKey block cache key + * @param block block contents + * @param context cache write context + */ + @Override + public void cacheBlock(BlockCacheKey cacheKey, Cacheable block, CacheWriteContext context) { + Objects.requireNonNull(cacheKey, "cacheKey must not be null"); + Objects.requireNonNull(block, "block must not be null"); + Objects.requireNonNull(context, "context must not be null"); + + AdmissionDecision admission = + policy.shouldAdmit(cacheKey, block, context, AdmissionPriority.NORMAL, topologyView); + if (!admission.isAdmitted()) { + return; + } + + policy.selectRepresentation(cacheKey, block, context, topologyView); + TierDecision tierDecision = policy.selectTier(cacheKey, block, context, topologyView); + for (CacheTier tier : tierDecision.getTiers()) { + Optional<CacheEngine> engine = topology.getEngine(tier); + if (engine.isPresent()) { + engine.get().cacheBlock(cacheKey, block, context.isInMemory(), context.isWaitWhenCache()); + } + } + } + + /** + * Evicts a single block from all engines participating in the topology. + * @param cacheKey block to remove + * @return {@code true} if at least one engine removed the block, {@code false} otherwise + */ + @Override + public boolean evictBlock(BlockCacheKey cacheKey) { + Objects.requireNonNull(cacheKey, "cacheKey must not be null"); + + boolean evicted = false; + for (CacheEngine engine : topology.getEngines()) { + evicted |= engine.evictBlock(cacheKey); + } + return evicted; + } + + /** + * Evicts all cached blocks for the given HFile from all engines participating in the topology. + * @param hfileName HFile name + * @return total number of blocks removed across all engines + */ + @Override + public int evictBlocksByHfileName(String hfileName) { + Objects.requireNonNull(hfileName, "hfileName must not be null"); + + int evicted = 0; + for (CacheEngine engine : topology.getEngines()) { + evicted += engine.evictBlocksByHfileName(hfileName); + } + return evicted; + } + + /** + * Evicts cached blocks for the given HFile range from all engines participating in the topology. + * @param hfileName HFile name + * @param initOffset inclusive start offset + * @param endOffset inclusive end offset + * @return total number of blocks removed across all engines + */ + @Override + public int evictBlocksRangeByHfileName(String hfileName, long initOffset, long endOffset) { + Objects.requireNonNull(hfileName, "hfileName must not be null"); + + int evicted = 0; Review Comment: Done. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
