diff --git a/build.gradle b/build.gradle index 8aad8910153..9a53d47e8f8 100644 --- a/build.gradle +++ b/build.gradle @@ -69,6 +69,7 @@ subprojects { configurations.all { resolutionStrategy { force group: 'com.google.guava', name: 'guava', version: '30.1-jre' + force group: 'com.github.ben-manes.caffeine', name: 'caffeine', version: '2.9.3' } } } diff --git a/common/build.gradle b/common/build.gradle index 0431316c009..89dce4a3ea4 100644 --- a/common/build.gradle +++ b/common/build.gradle @@ -53,6 +53,8 @@ dependencies { compile 'org.aspectj:aspectjrt:1.8.13' compile 'org.aspectj:aspectjweaver:1.8.13' compile 'org.aspectj:aspectjtools:1.8.13' + compile group: 'com.github.ben-manes.caffeine', name: 'caffeine', version: '2.9.3' + compile group: 'io.github.tronprotocol', name: 'libp2p', version: '2.1.0',{ exclude group: 'io.grpc', module: 'grpc-context' exclude group: 'io.grpc', module: 'grpc-core' diff --git a/common/src/main/java/org/tron/common/cache/CommonCache.java b/common/src/main/java/org/tron/common/cache/CommonCache.java new file mode 100644 index 00000000000..28710a31eee --- /dev/null +++ b/common/src/main/java/org/tron/common/cache/CommonCache.java @@ -0,0 +1,80 @@ +package org.tron.common.cache; + +import com.google.errorprone.annotations.CompatibleWith; +import lombok.extern.slf4j.Slf4j; +import org.tron.common.parameter.CommonParameter; + +import java.util.concurrent.ConcurrentMap; + +@Slf4j(topic = "app") +public class CommonCache { + + private com.github.benmanes.caffeine.cache.Cache caffeineCache; + private com.google.common.cache.Cache guavaCache; + private boolean isCaffeine = CommonParameter.getInstance().caffeineCacheActive; + + public CommonCache(com.github.benmanes.caffeine.cache.Cache caffeineCache, + com.google.common.cache.Cache guavaCache) { + if (isCaffeine) { + this.caffeineCache = caffeineCache; + this.guavaCache = null; + } else { + this.caffeineCache = null; + this.guavaCache = guavaCache; + } + } + + public V getIfPresent(@CompatibleWith("K") Object key) { + if (isCaffeine) { + logger.info("isCaffeine get {}", caffeineCache.getIfPresent(key) == null?" null":" not null"); + return (V)caffeineCache.getIfPresent(key); + } else { + logger.info("isGuava get {}", guavaCache.getIfPresent(key) == null?" null":" not null"); + return (V)guavaCache.getIfPresent(key); + } + } + + public void put(K key, V value) { + if (isCaffeine) { + logger.info("isCaffeine put"); + caffeineCache.put(key, value); + } else { + logger.info("isGuava put"); + guavaCache.put(key, value); + } + } + + public void invalidate(K key) { + if (isCaffeine) { + caffeineCache.invalidate(key); + } else { + guavaCache.invalidate(key); + } + } + + public ConcurrentMap asMap() { + if (isCaffeine) { + return caffeineCache.asMap(); + } else { + return guavaCache.asMap(); + } + } + + + public void cleanUp() { + if (isCaffeine) { + caffeineCache.cleanUp(); + } else { + guavaCache.cleanUp(); + } + } + + public long size() { + if (isCaffeine) { + return caffeineCache.estimatedSize(); + } else { + return guavaCache.size(); + } + } + +} diff --git a/common/src/main/java/org/tron/common/cache/CommonCacheBuilder.java b/common/src/main/java/org/tron/common/cache/CommonCacheBuilder.java new file mode 100644 index 00000000000..f3549ca457d --- /dev/null +++ b/common/src/main/java/org/tron/common/cache/CommonCacheBuilder.java @@ -0,0 +1,102 @@ +package org.tron.common.cache; + +import com.github.benmanes.caffeine.cache.Caffeine; +import com.google.common.cache.CacheBuilder; +import org.tron.common.parameter.CommonParameter; + +import java.util.concurrent.TimeUnit; + +public class CommonCacheBuilder { + private boolean isCaffeine = CommonParameter.getInstance().caffeineCacheActive; + private int initialCapacity = 0; + private long maximumSize = 0L; + private long expireAfterWrite = 0L; + private TimeUnit timeUnit; + private boolean recordStats = false; + + public CommonCacheBuilder initialCapacity(int initialCapacity) { + this.initialCapacity = initialCapacity; + return this; + } + + public CommonCacheBuilder maximumSize(long maximumSize) { + this.maximumSize = maximumSize; + return this; + } + + public CommonCacheBuilder expireAfterWrite(long expireAfterWrite, + TimeUnit timeUnit) { + this.expireAfterWrite = expireAfterWrite; + this.timeUnit = timeUnit; + return this; + } + + public CommonCacheBuilder recordStats() { + this.recordStats = true; + return this; + } + + public CommonCache build() { + //check + if (isCaffeine) { + com.github.benmanes.caffeine.cache.Caffeine caffeine = initCaffeineCacheBuilder( + initialCapacity, maximumSize, expireAfterWrite, timeUnit, recordStats + ); + com.github.benmanes.caffeine.cache.Cache caffeineCache = caffeine.build(); + return new CommonCache(caffeineCache, null); + } else { + com.google.common.cache.CacheBuilder cacheBuilder = initGuavaCacheBuilder( + initialCapacity, maximumSize, expireAfterWrite, timeUnit, recordStats + ); + com.google.common.cache.Cache guavaCache = cacheBuilder.build(); + return new CommonCache(null, guavaCache); + } + } + + + private com.google.common.cache.CacheBuilder initGuavaCacheBuilder(int initialCapacity + , long maximumSize + , long expireAfterWrite + , TimeUnit timeUnit + , boolean recordStats) { + com.google.common.cache.CacheBuilder cacheBuilder = CacheBuilder.newBuilder(); + if (initialCapacity > 0) { + cacheBuilder = cacheBuilder.initialCapacity(initialCapacity); + } + if (maximumSize > 0) { + cacheBuilder = cacheBuilder.maximumSize(maximumSize); + } + if (expireAfterWrite > 0) { + cacheBuilder = cacheBuilder.expireAfterWrite(expireAfterWrite, timeUnit); + } + if (recordStats) { + cacheBuilder = cacheBuilder.recordStats(); + } + return cacheBuilder; + } + + private com.github.benmanes.caffeine.cache.Caffeine initCaffeineCacheBuilder(int initialCapacity + , long maximumSize + , long expireAfterWrite + , TimeUnit timeUnit + , boolean recordStats) { + com.github.benmanes.caffeine.cache.Caffeine caffeine = Caffeine.newBuilder(); + if (initialCapacity > 0) { + caffeine = caffeine.initialCapacity(initialCapacity); + } + if (maximumSize > 0) { + caffeine = caffeine.maximumSize(maximumSize); + } + if (expireAfterWrite > 0) { + caffeine = caffeine.expireAfterWrite(expireAfterWrite, timeUnit); + } + if (recordStats) { + caffeine = caffeine.recordStats(); + } + return caffeine; + } + + public static CommonCacheBuilder newBuilder() { + return new CommonCacheBuilder<>(); + } +} diff --git a/common/src/main/java/org/tron/common/cache/CommonCacheStat.java b/common/src/main/java/org/tron/common/cache/CommonCacheStat.java new file mode 100644 index 00000000000..99717c38f9a --- /dev/null +++ b/common/src/main/java/org/tron/common/cache/CommonCacheStat.java @@ -0,0 +1,26 @@ +package org.tron.common.cache; + +import com.google.common.cache.CacheStats; +import lombok.Getter; + +public class CommonCacheStat { + @Getter + private CacheStats guavaCacheStats; + @Getter + private com.github.benmanes.caffeine.cache.stats.CacheStats caffeineCacheStats; + public CommonCacheStat(CacheStats guavaCacheStats, + com.github.benmanes.caffeine.cache.stats.CacheStats caffeineCacheStats) { + this.guavaCacheStats = guavaCacheStats; + this.caffeineCacheStats = caffeineCacheStats; + } + + + public static CacheStats castCaffeineToGuavaStat(com.github.benmanes.caffeine.cache.stats.CacheStats caffeineCacheStats) { + CacheStats guavaCacheStats = new CacheStats( + caffeineCacheStats.hitCount(), caffeineCacheStats.missCount(), + caffeineCacheStats.loadSuccessCount(), caffeineCacheStats.loadFailureCount(), + caffeineCacheStats.totalLoadTime(), caffeineCacheStats.evictionCount() + ); + return guavaCacheStats; + } +} diff --git a/common/src/main/java/org/tron/common/cache/TronCache.java b/common/src/main/java/org/tron/common/cache/TronCache.java index 4faf73f864a..5fc53672138 100644 --- a/common/src/main/java/org/tron/common/cache/TronCache.java +++ b/common/src/main/java/org/tron/common/cache/TronCache.java @@ -1,48 +1,90 @@ package org.tron.common.cache; +import com.github.benmanes.caffeine.cache.Caffeine; import com.google.common.base.Objects; import com.google.common.cache.Cache; import com.google.common.cache.CacheBuilder; import com.google.common.cache.CacheLoader; import com.google.common.cache.CacheStats; +import lombok.extern.slf4j.Slf4j; +import org.tron.common.parameter.CommonParameter; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; +import java.util.function.Function; + import lombok.Getter; +@Slf4j(topic = "app") public class TronCache { @Getter private final CacheType name; private final Cache cache; + private final com.github.benmanes.caffeine.cache.Cache caffeineCache; + private boolean isCaffeine = CommonParameter.getInstance().caffeineCacheActive; TronCache(CacheType name, String strategy) { this.name = name; - this.cache = CacheBuilder.from(strategy).build(); + if (isCaffeine) { + this.cache = null; + strategy = castGuavaSpec2Caffeine(strategy); + this.caffeineCache = Caffeine.from(strategy).build(); + } else { + this.cache = CacheBuilder.from(strategy).build(); + this.caffeineCache = null; + } } TronCache(CacheType name, String strategy, CacheLoader loader) { this.name = name; + this.caffeineCache = null; this.cache = CacheBuilder.from(strategy).build(loader); } public void put(K k, V v) { - this.cache.put(k, v); + if(isCaffeine) { + logger.info("isCaffeine put"); + this.caffeineCache.put(k, v); + } else { + logger.info("isGuava put"); + this.cache.put(k, v); + } } public V getIfPresent(K k) { - return this.cache.getIfPresent(k); + if(isCaffeine) { + logger.info("isCaffeine {}", this.caffeineCache.getIfPresent(k) == null?" null":" not null"); + return this.caffeineCache.getIfPresent(k); + } else { + logger.info("isGuava {}", this.cache.getIfPresent(k) == null?" null":" not null"); + return this.cache.getIfPresent(k); + } } public V get(K k, Callable loader) throws ExecutionException { - return this.cache.get(k, loader); + if(isCaffeine) { + logger.info("isCaffeine {}", this.caffeineCache.get(k, (Function) loader) == null?" null":" not null"); + return this.caffeineCache.get(k, (Function) loader); + } else { + logger.info("isGuava {}", this.cache.get(k, loader) == null?" null":" not null"); + return this.cache.get(k, loader); + } } public CacheStats stats() { - return this.cache.stats(); + if(isCaffeine){ + return CommonCacheStat.castCaffeineToGuavaStat(this.caffeineCache.stats()); + } else { + return this.cache.stats(); + } } public void invalidateAll() { - this.cache.invalidateAll(); + if (isCaffeine) { + this.caffeineCache.invalidateAll(); + } else { + this.cache.invalidateAll(); + } } @Override @@ -61,4 +103,11 @@ public boolean equals(Object o) { public int hashCode() { return Objects.hashCode(name); } + + private static String castGuavaSpec2Caffeine(String guavaSpec) { + int beforeConcurrencyLevel = guavaSpec.indexOf(",concurrencyLevel"); + int beforeRecordStats = guavaSpec.indexOf(",recordStats"); + String ret = guavaSpec.substring(0, beforeConcurrencyLevel) + guavaSpec.substring(beforeRecordStats, guavaSpec.length()); + return ret; + } } diff --git a/common/src/main/java/org/tron/common/parameter/CommonParameter.java b/common/src/main/java/org/tron/common/parameter/CommonParameter.java index 1ad50e1e359..8e7572511f3 100644 --- a/common/src/main/java/org/tron/common/parameter/CommonParameter.java +++ b/common/src/main/java/org/tron/common/parameter/CommonParameter.java @@ -654,6 +654,10 @@ public class CommonParameter { @Setter public long allowCancelAllUnfreezeV2; + @Getter + @Setter + public boolean caffeineCacheActive; + private static double calcMaxTimeRatio() { //return max(2.0, min(5.0, 5 * 4.0 / max(Runtime.getRuntime().availableProcessors(), 1))); return 5.0; diff --git a/common/src/main/java/org/tron/core/Constant.java b/common/src/main/java/org/tron/core/Constant.java index d7ec3b715c9..b3e37f79c0d 100644 --- a/common/src/main/java/org/tron/core/Constant.java +++ b/common/src/main/java/org/tron/core/Constant.java @@ -373,4 +373,6 @@ public class Constant { public static final String DYNAMIC_CONFIG_CHECK_INTERVAL = "node.dynamicConfig.checkInterval"; public static final String COMMITTEE_ALLOW_TVM_SHANGHAI = "committee.allowTvmShangHai"; + + public static final String NODE_CACHE_CAFFEINE_ACTIVE = "node.cache.caffeine.active"; } diff --git a/consensus/src/main/java/org/tron/consensus/pbft/PbftMessageHandle.java b/consensus/src/main/java/org/tron/consensus/pbft/PbftMessageHandle.java index ea7b00802b2..1156b1101bc 100644 --- a/consensus/src/main/java/org/tron/consensus/pbft/PbftMessageHandle.java +++ b/consensus/src/main/java/org/tron/consensus/pbft/PbftMessageHandle.java @@ -1,5 +1,6 @@ package org.tron.consensus.pbft; +import com.github.benmanes.caffeine.cache.Caffeine; import com.google.common.cache.Cache; import com.google.common.cache.CacheBuilder; import com.google.common.cache.CacheLoader; @@ -25,6 +26,11 @@ import org.apache.commons.lang3.StringUtils; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; + +import org.tron.common.cache.CommonCache; +import org.tron.common.cache.CommonCacheBuilder; + +import org.tron.common.parameter.CommonParameter; import org.tron.consensus.base.Param; import org.tron.consensus.base.Param.Miner; import org.tron.consensus.dpos.MaintenanceManager; @@ -33,6 +39,8 @@ import org.tron.core.ChainBaseManager; import org.tron.protos.Protocol.PBFTMessage.DataType; + + @Slf4j(topic = "pbft") @Component public class PbftMessageHandle { @@ -43,12 +51,12 @@ public class PbftMessageHandle { //Preparation stage voting information private Map pareVoteMap = Maps.newConcurrentMap(); private AtomicLongMap agreePare = AtomicLongMap.create(); - private Cache pareMsgCache = CacheBuilder.newBuilder() + private CommonCache pareMsgCache = CommonCacheBuilder.newBuilder() .initialCapacity(1000).maximumSize(10000).expireAfterWrite(2, TimeUnit.MINUTES).build(); //Submit stage voting information private Map commitVoteMap = Maps.newConcurrentMap(); private AtomicLongMap agreeCommit = AtomicLongMap.create(); - private Cache commitMsgCache = CacheBuilder.newBuilder() + private CommonCache commitMsgCache = CommonCacheBuilder.newBuilder() .initialCapacity(1000).maximumSize(10000).expireAfterWrite(2, TimeUnit.MINUTES).build(); //pbft timeout private Map timeOuts = Maps.newConcurrentMap(); @@ -64,6 +72,13 @@ public List load(String s) throws Exception { } }); + private boolean isCaffeine = CommonParameter.getInstance().caffeineCacheActive; + private com.github.benmanes.caffeine.cache.LoadingCache> dataCaffeineSignCache = + Caffeine.newBuilder() + .initialCapacity(100).maximumSize(1000).expireAfterWrite(2, TimeUnit.MINUTES) + .build(key -> createExpensiveGraph(key)); + + private PbftMessage srPbftMessage; private Timer timer = new Timer("pbft-timer"); @@ -75,6 +90,11 @@ public List load(String s) throws Exception { @Autowired private ChainBaseManager chainBaseManager; + + private List createExpensiveGraph(String s) { + return new ArrayList<>(); + } + @PostConstruct public void init() { start(); @@ -205,14 +225,25 @@ public synchronized void onCommit(PbftMessage message) { commitVoteMap.put(key, message); //The number of votes plus 1 long agCou = agreeCommit.incrementAndGet(message.getDataKey()); - dataSignCache.getUnchecked(message.getDataKey()) - .add(message.getPbftMessage().getSignature()); + if (isCaffeine) { + dataCaffeineSignCache.get(message.getDataKey()) + .add(message.getPbftMessage().getSignature()); + } else { + dataSignCache.getUnchecked(message.getDataKey()) + .add(message.getPbftMessage().getSignature()); + } + if (agCou >= Param.getInstance().getAgreeNodeCount()) { srPbftMessage = null; remove(message.getNo()); //commit, if (!isSyncing()) { - pbftMessageAction.action(message, dataSignCache.getUnchecked(message.getDataKey())); + if (isCaffeine) { + pbftMessageAction.action(message, dataCaffeineSignCache.get(message.getDataKey())); + } else { + pbftMessageAction.action(message, dataSignCache.getUnchecked(message.getDataKey())); + } + } } } diff --git a/framework/src/main/java/org/tron/core/config/args/Args.java b/framework/src/main/java/org/tron/core/config/args/Args.java index aff6708dfff..83012241d7d 100644 --- a/framework/src/main/java/org/tron/core/config/args/Args.java +++ b/framework/src/main/java/org/tron/core/config/args/Args.java @@ -230,6 +230,7 @@ public static void clearParam() { PARAMETER.dynamicConfigEnable = false; PARAMETER.dynamicConfigCheckInterval = 600; PARAMETER.allowTvmShangHai = 0; + PARAMETER.caffeineCacheActive = false; } /** @@ -1182,6 +1183,10 @@ public static void setParam(final String[] args, final String confFileName) { config.hasPath(Constant.COMMITTEE_ALLOW_TVM_SHANGHAI) ? config .getInt(Constant.COMMITTEE_ALLOW_TVM_SHANGHAI) : 0; + PARAMETER.caffeineCacheActive = + config.hasPath(Constant.NODE_CACHE_CAFFEINE_ACTIVE) ? config + .getBoolean(Constant.NODE_CACHE_CAFFEINE_ACTIVE) : false; + logConfig(); } @@ -1661,6 +1666,9 @@ public static void logConfig() { logger.info("ShutDown blockHeight : {}", parameter.getShutdownBlockHeight()); logger.info("ShutDown blockCount : {}", parameter.getShutdownBlockCount()); logger.info("***************************************************************"); + logger.info("************************ cache config *************************"); + logger.info("local cache caffeine active: {}", parameter.caffeineCacheActive); + logger.info("***************************************************************"); logger.info("\n"); } diff --git a/framework/src/main/java/org/tron/core/db/Manager.java b/framework/src/main/java/org/tron/core/db/Manager.java index b0d902eb84a..4ce2adedf63 100644 --- a/framework/src/main/java/org/tron/core/db/Manager.java +++ b/framework/src/main/java/org/tron/core/db/Manager.java @@ -48,6 +48,10 @@ import org.tron.api.GrpcAPI.TransactionInfoList; import org.tron.common.args.GenesisBlock; import org.tron.common.bloom.Bloom; + +import org.tron.common.cache.CommonCache; +import org.tron.common.cache.CommonCacheBuilder; + import org.tron.common.es.ExecutorServiceManager; import org.tron.common.logsfilter.EventPluginLoader; import org.tron.common.logsfilter.FilterQuery; @@ -210,7 +214,7 @@ public class Manager { private boolean isRunTriggerCapsuleProcessThread = true; private BlockingQueue pushTransactionQueue = new LinkedBlockingQueue<>(); @Getter - private Cache transactionIdCache = CacheBuilder + private CommonCache transactionIdCache = CommonCacheBuilder .newBuilder().maximumSize(TX_ID_CACHE_SIZE) .expireAfterWrite(1, TimeUnit.HOURS).recordStats().build(); @Autowired diff --git a/framework/src/main/java/org/tron/core/net/TronNetDelegate.java b/framework/src/main/java/org/tron/core/net/TronNetDelegate.java index 5d09e67908d..5e772ecedf4 100644 --- a/framework/src/main/java/org/tron/core/net/TronNetDelegate.java +++ b/framework/src/main/java/org/tron/core/net/TronNetDelegate.java @@ -19,6 +19,10 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import org.tron.common.backup.socket.BackupServer; + +import org.tron.common.cache.CommonCache; +import org.tron.common.cache.CommonCacheBuilder; + import org.tron.common.overlay.message.Message; import org.tron.common.prometheus.MetricKeys; import org.tron.common.prometheus.MetricLabels; @@ -98,7 +102,7 @@ public class TronNetDelegate { @Setter private volatile boolean exit = true; - private Cache freshBlockId = CacheBuilder.newBuilder() + private CommonCache freshBlockId = CommonCacheBuilder.newBuilder() .maximumSize(blockIdCacheSize).expireAfterWrite(1, TimeUnit.HOURS) .recordStats().build(); diff --git a/framework/src/main/java/org/tron/core/net/messagehandler/FetchInvDataMsgHandler.java b/framework/src/main/java/org/tron/core/net/messagehandler/FetchInvDataMsgHandler.java index 5e797c084b3..1b373cea4cc 100644 --- a/framework/src/main/java/org/tron/core/net/messagehandler/FetchInvDataMsgHandler.java +++ b/framework/src/main/java/org/tron/core/net/messagehandler/FetchInvDataMsgHandler.java @@ -8,6 +8,10 @@ import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; + +import org.tron.common.cache.CommonCache; +import org.tron.common.cache.CommonCacheBuilder; + import org.tron.common.overlay.message.Message; import org.tron.common.utils.Sha256Hash; import org.tron.consensus.ConsensusDelegate; @@ -37,8 +41,9 @@ @Component public class FetchInvDataMsgHandler implements TronMsgHandler { - private volatile Cache epochCache = CacheBuilder.newBuilder().initialCapacity(100) - .maximumSize(1000).expireAfterWrite(1, TimeUnit.HOURS).build(); + private volatile CommonCache epochCache = CommonCacheBuilder.newBuilder() + .initialCapacity(100).maximumSize(1000).expireAfterWrite(1, TimeUnit.HOURS) + .build(); private static final int MAX_SIZE = 1_000_000; @Autowired diff --git a/framework/src/main/java/org/tron/core/net/messagehandler/PbftMsgHandler.java b/framework/src/main/java/org/tron/core/net/messagehandler/PbftMsgHandler.java index 4e4cc858898..b14f8345419 100644 --- a/framework/src/main/java/org/tron/core/net/messagehandler/PbftMsgHandler.java +++ b/framework/src/main/java/org/tron/core/net/messagehandler/PbftMsgHandler.java @@ -7,6 +7,10 @@ import java.util.concurrent.locks.Lock; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; + +import org.tron.common.cache.CommonCache; +import org.tron.common.cache.CommonCacheBuilder; + import org.tron.consensus.base.Param; import org.tron.consensus.pbft.PbftManager; import org.tron.consensus.pbft.message.PbftBaseMessage; @@ -23,7 +27,7 @@ public class PbftMsgHandler { private static final Striped striped = Striped.lazyWeakLock(1024); - private static final Cache msgCache = CacheBuilder.newBuilder() + private static final CommonCache msgCache = CommonCacheBuilder.newBuilder() .initialCapacity(3000).maximumSize(10000).expireAfterWrite(10, TimeUnit.MINUTES).build(); @Autowired diff --git a/framework/src/main/java/org/tron/core/net/peer/PeerConnection.java b/framework/src/main/java/org/tron/core/net/peer/PeerConnection.java index 6743f00421d..7e7a3ce9dea 100644 --- a/framework/src/main/java/org/tron/core/net/peer/PeerConnection.java +++ b/framework/src/main/java/org/tron/core/net/peer/PeerConnection.java @@ -20,6 +20,10 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Component; + +import org.tron.common.cache.CommonCache; +import org.tron.common.cache.CommonCacheBuilder; + import org.tron.common.overlay.message.Message; import org.tron.common.prometheus.MetricKeys; import org.tron.common.prometheus.Metrics; @@ -106,13 +110,15 @@ public class PeerConnection { @Setter @Getter - private Cache advInvReceive = CacheBuilder.newBuilder().maximumSize(invCacheSize) - .expireAfterWrite(1, TimeUnit.HOURS).recordStats().build(); + private CommonCache advInvReceive = CommonCacheBuilder.newBuilder() + .maximumSize(invCacheSize).expireAfterWrite(1, TimeUnit.HOURS).recordStats() + .build(); @Setter @Getter - private Cache advInvSpread = CacheBuilder.newBuilder().maximumSize(invCacheSize) - .expireAfterWrite(1, TimeUnit.HOURS).recordStats().build(); + private CommonCache advInvSpread = CommonCacheBuilder.newBuilder() + .maximumSize(invCacheSize).expireAfterWrite(1, TimeUnit.HOURS).recordStats() + .build(); @Setter @Getter @@ -132,8 +138,9 @@ public class PeerConnection { @Getter private volatile long remainNum; @Getter - private Cache syncBlockIdCache = CacheBuilder.newBuilder() - .maximumSize(2 * NetConstants.SYNC_FETCH_BATCH_NUM).recordStats().build(); + private CommonCache syncBlockIdCache = CommonCacheBuilder.newBuilder() + .maximumSize(2 * NetConstants.SYNC_FETCH_BATCH_NUM).recordStats() + .build(); @Setter @Getter private Deque syncBlockToFetch = new ConcurrentLinkedDeque<>(); diff --git a/framework/src/main/java/org/tron/core/net/service/adv/AdvService.java b/framework/src/main/java/org/tron/core/net/service/adv/AdvService.java index ea608c1ea86..85cf5465f25 100644 --- a/framework/src/main/java/org/tron/core/net/service/adv/AdvService.java +++ b/framework/src/main/java/org/tron/core/net/service/adv/AdvService.java @@ -21,6 +21,10 @@ import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; + +import org.tron.common.cache.CommonCache; +import org.tron.common.cache.CommonCacheBuilder; + import org.tron.common.es.ExecutorServiceManager; import org.tron.common.overlay.message.Message; import org.tron.common.utils.Sha256Hash; @@ -58,16 +62,16 @@ public class AdvService { private ConcurrentHashMap invToSpread = new ConcurrentHashMap<>(); private long blockCacheTimeout = Args.getInstance().getBlockCacheTimeout(); - private Cache invToFetchCache = CacheBuilder.newBuilder() + private CommonCache invToFetchCache = CommonCacheBuilder.newBuilder() .maximumSize(MAX_INV_TO_FETCH_CACHE_SIZE) .expireAfterWrite(blockCacheTimeout, TimeUnit.MINUTES) .recordStats().build(); - private Cache trxCache = CacheBuilder.newBuilder() + private CommonCache trxCache = CommonCacheBuilder.newBuilder() .maximumSize(MAX_TRX_CACHE_SIZE).expireAfterWrite(1, TimeUnit.HOURS) .recordStats().build(); - private Cache blockCache = CacheBuilder.newBuilder() + private CommonCache blockCache = CommonCacheBuilder.newBuilder() .maximumSize(MAX_BLOCK_CACHE_SIZE).expireAfterWrite(1, TimeUnit.MINUTES) .recordStats().build(); diff --git a/framework/src/main/java/org/tron/core/net/service/effective/EffectiveCheckService.java b/framework/src/main/java/org/tron/core/net/service/effective/EffectiveCheckService.java index a4e89412bae..e9bcc38b2ea 100644 --- a/framework/src/main/java/org/tron/core/net/service/effective/EffectiveCheckService.java +++ b/framework/src/main/java/org/tron/core/net/service/effective/EffectiveCheckService.java @@ -16,6 +16,10 @@ import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; + +import org.tron.common.cache.CommonCache; +import org.tron.common.cache.CommonCacheBuilder; + import org.tron.common.es.ExecutorServiceManager; import org.tron.core.config.args.Args; import org.tron.core.net.TronNetDelegate; @@ -33,7 +37,7 @@ public class EffectiveCheckService { @Autowired private TronNetDelegate tronNetDelegate; - private final Cache nodesCache = CacheBuilder.newBuilder() + private final CommonCache nodesCache = CommonCacheBuilder.newBuilder() .initialCapacity(100) .maximumSize(10000) .expireAfterWrite(20, TimeUnit.MINUTES).build(); diff --git a/framework/src/main/java/org/tron/core/net/service/statistics/TronStatsManager.java b/framework/src/main/java/org/tron/core/net/service/statistics/TronStatsManager.java index caac3f7f325..2d06b870b51 100644 --- a/framework/src/main/java/org/tron/core/net/service/statistics/TronStatsManager.java +++ b/framework/src/main/java/org/tron/core/net/service/statistics/TronStatsManager.java @@ -7,6 +7,10 @@ import java.util.concurrent.TimeUnit; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Component; + +import org.tron.common.cache.CommonCache; +import org.tron.common.cache.CommonCacheBuilder; + import org.tron.common.es.ExecutorServiceManager; import org.tron.common.prometheus.MetricKeys; import org.tron.common.prometheus.MetricLabels; @@ -24,7 +28,7 @@ public class TronStatsManager { private volatile long UDP_TRAFFIC_IN = 0; private volatile long UDP_TRAFFIC_OUT = 0; - private static Cache cache = CacheBuilder.newBuilder() + private static CommonCache cache = CommonCacheBuilder.newBuilder() .maximumSize(3000).recordStats().build(); private final String esName = "net-traffic-collector"; diff --git a/framework/src/main/java/org/tron/core/net/service/sync/SyncService.java b/framework/src/main/java/org/tron/core/net/service/sync/SyncService.java index 1e3e18441b9..b2dab8e3cd8 100644 --- a/framework/src/main/java/org/tron/core/net/service/sync/SyncService.java +++ b/framework/src/main/java/org/tron/core/net/service/sync/SyncService.java @@ -17,6 +17,10 @@ import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; + +import org.tron.common.cache.CommonCache; +import org.tron.common.cache.CommonCacheBuilder; + import org.tron.common.es.ExecutorServiceManager; import org.tron.common.utils.Pair; import org.tron.core.capsule.BlockCapsule; @@ -49,7 +53,7 @@ public class SyncService { private Map blockJustReceived = new ConcurrentHashMap<>(); private long blockCacheTimeout = Args.getInstance().getBlockCacheTimeout(); - private Cache requestBlockIds = CacheBuilder.newBuilder() + private CommonCache requestBlockIds = CommonCacheBuilder.newBuilder() .maximumSize(10_000) .expireAfterWrite(blockCacheTimeout, TimeUnit.MINUTES).initialCapacity(10_000) .recordStats().build(); diff --git a/framework/src/main/java/org/tron/core/services/WitnessProductBlockService.java b/framework/src/main/java/org/tron/core/services/WitnessProductBlockService.java index e895923114f..31d9de07ac3 100644 --- a/framework/src/main/java/org/tron/core/services/WitnessProductBlockService.java +++ b/framework/src/main/java/org/tron/core/services/WitnessProductBlockService.java @@ -10,6 +10,10 @@ import java.util.concurrent.atomic.AtomicInteger; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; + +import org.tron.common.cache.CommonCache; +import org.tron.common.cache.CommonCacheBuilder; + import org.tron.common.utils.ByteArray; import org.tron.core.capsule.BlockCapsule; @@ -17,7 +21,7 @@ @Service public class WitnessProductBlockService { - private Cache historyBlockCapsuleCache = CacheBuilder.newBuilder() + private CommonCache historyBlockCapsuleCache = CommonCacheBuilder.newBuilder() .initialCapacity(200).maximumSize(200).build(); private Map cheatWitnessInfoMap = new HashMap<>(); diff --git a/framework/src/main/java/org/tron/core/services/ratelimiter/GlobalRateLimiter.java b/framework/src/main/java/org/tron/core/services/ratelimiter/GlobalRateLimiter.java index a3b1638ac95..62c4ec360e4 100644 --- a/framework/src/main/java/org/tron/core/services/ratelimiter/GlobalRateLimiter.java +++ b/framework/src/main/java/org/tron/core/services/ratelimiter/GlobalRateLimiter.java @@ -5,6 +5,10 @@ import com.google.common.cache.CacheBuilder; import com.google.common.util.concurrent.RateLimiter; import java.util.concurrent.TimeUnit; + +import org.tron.common.cache.CommonCache; +import org.tron.common.cache.CommonCacheBuilder; + import org.tron.core.config.args.Args; public class GlobalRateLimiter { @@ -13,7 +17,7 @@ public class GlobalRateLimiter { private static double IP_QPS = Args.getInstance().getRateLimiterGlobalIpQps(); - private static Cache cache = CacheBuilder.newBuilder() + private static CommonCache cache = CommonCacheBuilder.newBuilder() .maximumSize(10000).expireAfterWrite(1, TimeUnit.HOURS).build(); private static RateLimiter rateLimiter = RateLimiter.create(QPS); diff --git a/framework/src/main/java/org/tron/core/services/ratelimiter/strategy/IPQpsStrategy.java b/framework/src/main/java/org/tron/core/services/ratelimiter/strategy/IPQpsStrategy.java index 713666a05e3..0d18ac0ea8b 100644 --- a/framework/src/main/java/org/tron/core/services/ratelimiter/strategy/IPQpsStrategy.java +++ b/framework/src/main/java/org/tron/core/services/ratelimiter/strategy/IPQpsStrategy.java @@ -7,13 +7,17 @@ import java.util.Map; import java.util.concurrent.TimeUnit; +import org.tron.common.cache.CommonCache; +import org.tron.common.cache.CommonCacheBuilder; + public class IPQpsStrategy extends Strategy { public static final String STRATEGY_PARAM_IPQPS = "qps"; public static final Double DEFAULT_IPQPS = 2D; - private Cache ipLimiter = CacheBuilder.newBuilder().maximumSize(10000) - .expireAfterWrite(600, TimeUnit.SECONDS).recordStats().build(); + private CommonCache ipLimiter = CommonCacheBuilder.newBuilder() + .maximumSize(10000).expireAfterWrite(600, TimeUnit.SECONDS).recordStats() + .build(); public IPQpsStrategy(String paramString) { super(paramString); diff --git a/framework/src/test/java/org/tron/core/net/messagehandler/FetchInvDataMsgHandlerTest.java b/framework/src/test/java/org/tron/core/net/messagehandler/FetchInvDataMsgHandlerTest.java index 404d275276a..9b8d11e82db 100644 --- a/framework/src/test/java/org/tron/core/net/messagehandler/FetchInvDataMsgHandlerTest.java +++ b/framework/src/test/java/org/tron/core/net/messagehandler/FetchInvDataMsgHandlerTest.java @@ -9,6 +9,9 @@ import org.junit.Assert; import org.junit.Test; import org.mockito.Mockito; +import org.tron.common.cache.CommonCache; +import org.tron.common.cache.CommonCacheBuilder; + import org.tron.common.utils.ReflectUtils; import org.tron.common.utils.Sha256Hash; import org.tron.core.capsule.BlockCapsule; @@ -42,14 +45,16 @@ public void testProcessMessage() throws Exception { List blockIds = new LinkedList<>(); blockIds.add(blockId); - Cache advInvSpread = CacheBuilder.newBuilder().maximumSize(20000) - .expireAfterWrite(1, TimeUnit.HOURS).recordStats().build(); + CommonCache advInvSpread = CommonCacheBuilder.newBuilder() + .maximumSize(20000).expireAfterWrite(1, TimeUnit.HOURS).recordStats() + .build(); Mockito.when(peer.getAdvInvSpread()).thenReturn(advInvSpread); Mockito.when(peer.isNeedSyncFromUs()).thenReturn(true); Mockito.when(peer.isSyncFinish()).thenReturn(false); Mockito.when(peer.getBlockBothHave()).thenReturn(blockId); - Cache syncBlockIdCache = CacheBuilder.newBuilder() - .maximumSize(2 * Parameter.NetConstants.SYNC_FETCH_BATCH_NUM).recordStats().build(); + CommonCache syncBlockIdCache = CommonCacheBuilder.newBuilder() + .maximumSize(2 * Parameter.NetConstants.SYNC_FETCH_BATCH_NUM).recordStats() + .build(); Mockito.when(peer.getSyncBlockIdCache()).thenReturn(syncBlockIdCache); Mockito.when(peer.getLastSyncBlockId()).thenReturn(blockId); BlockCapsule blockCapsule = new BlockCapsule(1, Sha256Hash.ZERO_HASH,