org.apache.hadoop.hbase.regionserver

Class ImmutableSegment

java.lang.Object

org.apache.hadoop.hbase.regionserver.Segment

org.apache.hadoop.hbase.regionserver.ImmutableSegment

Direct Known Subclasses:

CompositeImmutableSegment

@InterfaceAudience.Private
public class ImmutableSegment
extends Segment

ImmutableSegment is an abstract class that extends the API supported by a Segment, and is not needed for a MutableSegment.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ImmutableSegment.Type Types of ImmutableSegment

Field Summary

Fields

Modifier and Type	Field and Description
static long	DEEP_OVERHEAD_CAM
static long	DEEP_OVERHEAD_CSLM

Fields inherited from class org.apache.hadoop.hbase.regionserver.Segment

dataSize, FIXED_OVERHEAD, heapSize, minSequenceId, tagsPresent, timeRangeTracker

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	ImmutableSegment(CellComparator comparator) ------------------------------------------------------------------------ Empty C-tor to be used only for CompositeImmutableSegment
protected	ImmutableSegment(CellComparator comparator, MemStoreSegmentsIterator iterator, MemStoreLAB memStoreLAB) ------------------------------------------------------------------------ C-tor to be used when new SKIP-LIST BASED ImmutableSegment is a result of compaction of a list of older ImmutableSegments.
protected	ImmutableSegment(CellComparator comparator, MemStoreSegmentsIterator iterator, MemStoreLAB memStoreLAB, int numOfCells, ImmutableSegment.Type type, boolean merge) ------------------------------------------------------------------------ C-tor to be used when new CELL_ARRAY BASED ImmutableSegment is a result of compaction of a list of older ImmutableSegments.
protected	ImmutableSegment(Segment segment) ------------------------------------------------------------------------ Copy C-tor to be used when new ImmutableSegment is being built from a Mutable one.

Method Summary

Modifier and Type	Method and Description
boolean	flatten(MemstoreSize memstoreSize) ------------------------------------------------------------------------ Change the CellSet of this ImmutableSegment from one based on ConcurrentSkipListMap to one based on CellArrayMap.
List<Segment>	getAllSegments()
long	getMinTimestamp()
int	getNumOfSegments()
protected long	heapSizeChange(Cell cell, boolean succ)
boolean	shouldSeek(TimeRange tr, long oldestUnexpiredTS)

Methods inherited from class org.apache.hadoop.hbase.regionserver.Segment

close, compare, compareRows, decScannerCount, getCellsCount, getCellSet, getComparator, getFirstAfter, getMinSequenceId, getScanner, getScanner, getScanners, getTimeRangeTracker, headSet, heapSize, incScannerCount, incSize, internalAdd, isEmpty, isTagsPresent, iterator, keySize, last, maybeCloneWithAllocator, setCellSet, tailSet, toString, updateMetaInfo

Methods inherited from class java.lang.Object

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

Field Detail

DEEP_OVERHEAD_CSLM

public static final long DEEP_OVERHEAD_CSLM

DEEP_OVERHEAD_CAM

public static final long DEEP_OVERHEAD_CAM

Constructor Detail

ImmutableSegment

protected ImmutableSegment(CellComparator comparator)

------------------------------------------------------------------------ Empty C-tor to be used only for CompositeImmutableSegment

ImmutableSegment

protected ImmutableSegment(Segment segment)

------------------------------------------------------------------------ Copy C-tor to be used when new ImmutableSegment is being built from a Mutable one. This C-tor should be used when active MutableSegment is pushed into the compaction pipeline and becomes an ImmutableSegment.

ImmutableSegment

protected ImmutableSegment(CellComparator comparator,
                           MemStoreSegmentsIterator iterator,
                           MemStoreLAB memStoreLAB,
                           int numOfCells,
                           ImmutableSegment.Type type,
                           boolean merge)

------------------------------------------------------------------------ C-tor to be used when new CELL_ARRAY BASED ImmutableSegment is a result of compaction of a list of older ImmutableSegments. The given iterator returns the Cells that "survived" the compaction. The input parameter "type" exists for future use when more types of flat ImmutableSegments are going to be introduced.

ImmutableSegment

protected ImmutableSegment(CellComparator comparator,
                           MemStoreSegmentsIterator iterator,
                           MemStoreLAB memStoreLAB)

------------------------------------------------------------------------ C-tor to be used when new SKIP-LIST BASED ImmutableSegment is a result of compaction of a list of older ImmutableSegments. The given iterator returns the Cells that "survived" the compaction.

Method Detail

shouldSeek

public boolean shouldSeek(TimeRange tr,
                          long oldestUnexpiredTS)

Specified by:

shouldSeek in class Segment

getMinTimestamp

public long getMinTimestamp()

Specified by:

getMinTimestamp in class Segment

getNumOfSegments

public int getNumOfSegments()

getAllSegments

public List<Segment> getAllSegments()

flatten

public boolean flatten(MemstoreSize memstoreSize)

------------------------------------------------------------------------ Change the CellSet of this ImmutableSegment from one based on ConcurrentSkipListMap to one based on CellArrayMap. If this ImmutableSegment is not based on ConcurrentSkipListMap , this is NOOP Synchronization of the CellSet replacement: The reference to the CellSet is AtomicReference and is updated only when ImmutableSegment is constructed (single thread) or flattened. The flattening happens as part of a single thread of compaction, but to be on the safe side the initial CellSet is locally saved before the flattening and then replaced using CAS instruction.

heapSizeChange

protected long heapSizeChange(Cell cell,
                              boolean succ)

Overrides:

heapSizeChange in class Segment

Returns:

The increase in heap size because of this cell addition. This includes this cell POJO's heap size itself and additional overhead because of addition on to CSLM.