org.apache.hadoop.hbase.regionserver.compactions

Class SortedCompactionPolicy

java.lang.Object

org.apache.hadoop.hbase.regionserver.compactions.CompactionPolicy

org.apache.hadoop.hbase.regionserver.compactions.SortedCompactionPolicy

Direct Known Subclasses:

DateTieredCompactionPolicy, RatioBasedCompactionPolicy

@InterfaceAudience.Private
public abstract class SortedCompactionPolicy
extends CompactionPolicy

An abstract compaction policy that select files on seq id order.

Field Summary

Fields

Modifier and Type	Field and Description
private static org.slf4j.Logger	LOG
private Random	random Used calculation jitter

Fields inherited from class org.apache.hadoop.hbase.regionserver.compactions.CompactionPolicy

comConf, storeConfigInfo

Constructor Summary

Constructors

Constructor and Description
SortedCompactionPolicy(org.apache.hadoop.conf.Configuration conf, StoreConfigInformation storeConfigInfo)

Method Summary

Modifier and Type	Method and Description
protected ArrayList<HStoreFile>	checkMinFilesCriteria(ArrayList<HStoreFile> candidates, int minFiles)
protected abstract CompactionRequestImpl	createCompactionRequest(ArrayList<HStoreFile> candidateSelection, boolean tryingMajor, boolean mayUseOffPeak, boolean mayBeStuck)
protected void	filterBulk(ArrayList<HStoreFile> candidates)
protected ArrayList<HStoreFile>	getCurrentEligibleFiles(ArrayList<HStoreFile> candidateFiles, List<HStoreFile> filesCompacting)
long	getNextMajorCompactTime(Collection<HStoreFile> filesToCompact)
abstract boolean	needsCompaction(Collection<HStoreFile> storeFiles, List<HStoreFile> filesCompacting)
List<HStoreFile>	preSelectCompactionForCoprocessor(Collection<HStoreFile> candidates, List<HStoreFile> filesCompacting)
protected void	removeExcessFiles(ArrayList<HStoreFile> candidates, boolean isUserCompaction, boolean isMajorCompaction)
CompactionRequestImpl	selectCompaction(Collection<HStoreFile> candidateFiles, List<HStoreFile> filesCompacting, boolean isUserCompaction, boolean mayUseOffPeak, boolean forceMajor)
abstract boolean	shouldPerformMajorCompaction(Collection<HStoreFile> filesToCompact)
protected ArrayList<HStoreFile>	skipLargeFiles(ArrayList<HStoreFile> candidates, boolean mayUseOffpeak)
boolean	throttleCompaction(long compactionSize)

Methods inherited from class org.apache.hadoop.hbase.regionserver.compactions.CompactionPolicy

getConf, setConf

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

LOG

private static final org.slf4j.Logger LOG

random

private final Random random

Used calculation jitter

Constructor Detail

SortedCompactionPolicy

public SortedCompactionPolicy(org.apache.hadoop.conf.Configuration conf,
                              StoreConfigInformation storeConfigInfo)

Method Detail

preSelectCompactionForCoprocessor

public List<HStoreFile> preSelectCompactionForCoprocessor(Collection<HStoreFile> candidates,
                                                          List<HStoreFile> filesCompacting)

selectCompaction

public CompactionRequestImpl selectCompaction(Collection<HStoreFile> candidateFiles,
                                              List<HStoreFile> filesCompacting,
                                              boolean isUserCompaction,
                                              boolean mayUseOffPeak,
                                              boolean forceMajor)
                                       throws IOException

Parameters:

candidateFiles - candidate files, ordered from oldest to newest by seqId. We rely on DefaultStoreFileManager to sort the files by seqId to guarantee contiguous compaction based on seqId for data consistency.

Returns:

subset copy of candidate list that meets compaction criteria

Throws:

IOException

createCompactionRequest

protected abstract CompactionRequestImpl createCompactionRequest(ArrayList<HStoreFile> candidateSelection,
                                                                 boolean tryingMajor,
                                                                 boolean mayUseOffPeak,
                                                                 boolean mayBeStuck)
                                                          throws IOException

Throws:

IOException

shouldPerformMajorCompaction

public abstract boolean shouldPerformMajorCompaction(Collection<HStoreFile> filesToCompact)
                                              throws IOException

Specified by:

shouldPerformMajorCompaction in class CompactionPolicy

Parameters:

filesToCompact - Files to compact. Can be null.

Returns:

True if we should run a major compaction.

Throws:

IOException

getNextMajorCompactTime

public long getNextMajorCompactTime(Collection<HStoreFile> filesToCompact)

Parameters:

filesToCompact -

Returns:

When to run next major compaction

throttleCompaction

public boolean throttleCompaction(long compactionSize)

Specified by:

throttleCompaction in class CompactionPolicy

Parameters:

compactionSize - Total size of some compaction

Returns:

whether this should be a large or small compaction

needsCompaction

public abstract boolean needsCompaction(Collection<HStoreFile> storeFiles,
                                        List<HStoreFile> filesCompacting)

getCurrentEligibleFiles

protected ArrayList<HStoreFile> getCurrentEligibleFiles(ArrayList<HStoreFile> candidateFiles,
                                                        List<HStoreFile> filesCompacting)

skipLargeFiles

protected ArrayList<HStoreFile> skipLargeFiles(ArrayList<HStoreFile> candidates,
                                               boolean mayUseOffpeak)

Parameters:

candidates - pre-filtrate

Returns:

filtered subset exclude all files above maxCompactSize Also save all references. We MUST compact them

filterBulk

protected void filterBulk(ArrayList<HStoreFile> candidates)

Parameters:

candidates - pre-filtrate

removeExcessFiles

protected void removeExcessFiles(ArrayList<HStoreFile> candidates,
                                 boolean isUserCompaction,
                                 boolean isMajorCompaction)

Parameters:

candidates - pre-filtrate

checkMinFilesCriteria

protected ArrayList<HStoreFile> checkMinFilesCriteria(ArrayList<HStoreFile> candidates,
                                                      int minFiles)

Parameters:

candidates - pre-filtrate

Returns:

filtered subset forget the compactionSelection if we don't have enough files