private void flush(Data key) {
checkIfLoaded();
EntryTaskScheduler writeScheduler = mapContainer.getMapStoreScheduler();
Set<Data> keys = new HashSet<Data>(1);
keys.add(key);
if (writeScheduler != null) {
Set<Data> processedKeys = writeScheduler.flush(keys);
for (Data pkey : processedKeys) {
records.get(pkey).onStore();
}
}
EntryTaskScheduler deleteScheduler = mapContainer.getMapStoreScheduler();
if (deleteScheduler != null) {
if (toBeRemovedKeys.contains(key)) {
deleteScheduler.flush(keys);
toBeRemovedKeys.remove(key);
}
}
}
public void flush() {
checkIfLoaded();
Set<Data> keys = new HashSet<Data>();
for (Record record : records.values()) {
keys.add(record.getKey());
}
EntryTaskScheduler writeScheduler = mapContainer.getMapStoreScheduler();
if (writeScheduler != null) {
Set<Data> processedKeys = writeScheduler.flush(keys);
for (Data key : processedKeys) {
records.get(key).onStore();
}
}
EntryTaskScheduler deleteScheduler = mapContainer.getMapStoreScheduler();
if (deleteScheduler != null) {
deleteScheduler.flush(toBeRemovedKeys);
toBeRemovedKeys.clear();
}
}
private void setDelays(MapContainer mapContainer, RecordInfo info, Data key, int extraDelay) {
long deleteDelay = -1;
long writeDelay = -1;
long idleDelay;
long ttlDelay;
if (mapContainer.getMapStoreScheduler() != null) {
final ScheduledEntry scheduledEntry = mapContainer.getMapStoreScheduler().get(key);
if (scheduledEntry != null) {
if (scheduledEntry.getValue() == null) {
deleteDelay = extraDelay + findDelayMillis(scheduledEntry);
} else {
writeDelay = extraDelay + findDelayMillis(scheduledEntry);
}
}
}
idleDelay = getDelay(mapContainer.getIdleEvictionScheduler(), key, extraDelay);
ttlDelay = getDelay(mapContainer.getTtlEvictionScheduler(), key, extraDelay);
// set delays.
info.setMapStoreDeleteDelayMillis(deleteDelay);
info.setMapStoreWriteDelayMillis(writeDelay);
info.setIdleDelayMillis(idleDelay);
info.setTtlDelayMillis(ttlDelay);
}
public LocalMapStatsImpl createLocalMapStats(String mapName) {
MapContainer mapContainer = getMapContainer(mapName);
LocalMapStatsImpl localMapStats = getLocalMapStatsImpl(mapName);
if (!mapContainer.getMapConfig().isStatisticsEnabled()) {
return localMapStats;
}
long ownedEntryCount = 0;
long backupEntryCount = 0;
long dirtyCount = 0;
long ownedEntryMemoryCost = 0;
long backupEntryMemoryCost = 0;
long hits = 0;
long lockedEntryCount = 0;
long heapCost = 0;
int backupCount = mapContainer.getTotalBackupCount();
ClusterService clusterService = nodeEngine.getClusterService();
final InternalPartitionService partitionService = nodeEngine.getPartitionService();
Address thisAddress = clusterService.getThisAddress();
for (int partitionId = 0; partitionId < partitionService.getPartitionCount(); partitionId++) {
InternalPartition partition = partitionService.getPartition(partitionId);
Address owner = partition.getOwner();
if (owner == null) {
// no-op because no owner is set yet. Therefor we don't know anything about the map
continue;
}
if (owner.equals(thisAddress)) {
PartitionContainer partitionContainer = getPartitionContainer(partitionId);
RecordStore recordStore = partitionContainer.getExistingRecordStore(mapName);
// we don't want to force loading the record store because we are loading statistics. So
// that is why
// we ask for 'getExistingRecordStore' instead of 'getRecordStore' which does the load.
if (recordStore != null) {
heapCost += recordStore.getHeapCost();
Map<Data, Record> records = recordStore.getReadonlyRecordMap();
for (Record record : records.values()) {
RecordStatistics stats = record.getStatistics();
// there is map store and the record is dirty (waits to be stored)
ownedEntryCount++;
ownedEntryMemoryCost += record.getCost();
localMapStats.setLastAccessTime(stats.getLastAccessTime());
localMapStats.setLastUpdateTime(stats.getLastUpdateTime());
hits += stats.getHits();
if (recordStore.isLocked(record.getKey())) {
lockedEntryCount++;
}
}
}
} else {
for (int replica = 1; replica <= backupCount; replica++) {
Address replicaAddress = partition.getReplicaAddress(replica);
int tryCount = 30;
// wait if the partition table is not updated yet
while (replicaAddress == null
&& clusterService.getSize() > backupCount
&& tryCount-- > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw ExceptionUtil.rethrow(e);
}
replicaAddress = partition.getReplicaAddress(replica);
}
if (replicaAddress != null && replicaAddress.equals(thisAddress)) {
PartitionContainer partitionContainer = getPartitionContainer(partitionId);
RecordStore recordStore = partitionContainer.getRecordStore(mapName);
heapCost += recordStore.getHeapCost();
Map<Data, Record> records = recordStore.getReadonlyRecordMap();
for (Record record : records.values()) {
backupEntryCount++;
backupEntryMemoryCost += record.getCost();
}
} else if (replicaAddress == null && clusterService.getSize() > backupCount) {
logger.warning("Partition: " + partition + ", replica: " + replica + " has no owner!");
}
}
}
}
if (mapContainer.getMapStoreScheduler() != null) {
dirtyCount = mapContainer.getMapStoreScheduler().size();
}
localMapStats.setBackupCount(backupCount);
localMapStats.setDirtyEntryCount(zeroOrPositive(dirtyCount));
localMapStats.setLockedEntryCount(zeroOrPositive(lockedEntryCount));
localMapStats.setHits(zeroOrPositive(hits));
localMapStats.setOwnedEntryCount(zeroOrPositive(ownedEntryCount));
localMapStats.setBackupEntryCount(zeroOrPositive(backupEntryCount));
localMapStats.setOwnedEntryMemoryCost(zeroOrPositive(ownedEntryMemoryCost));
localMapStats.setBackupEntryMemoryCost(zeroOrPositive(backupEntryMemoryCost));
// add near cache heap cost.
heapCost += mapContainer.getNearCacheSizeEstimator().getSize();
localMapStats.setHeapCost(heapCost);
if (mapContainer.getMapConfig().isNearCacheEnabled()) {
NearCacheStatsImpl nearCacheStats = getNearCache(mapName).getNearCacheStats();
localMapStats.setNearCacheStats(nearCacheStats);
}
return localMapStats;
}