org.apache.hadoop.hbase.regionserver

Class Segment

java.lang.Object

org.apache.hadoop.hbase.regionserver.Segment

All Implemented Interfaces:

MemStoreSizing

Direct Known Subclasses:

ImmutableSegment, MutableSegment

@InterfaceAudience.Private
public abstract class Segment
extends Object
implements MemStoreSizing

This is an abstraction of a segment maintained in a memstore, e.g., the active cell set or its snapshot. This abstraction facilitates the management of the compaction pipeline and the shifts of these segments from active set to snapshot set in the default implementation.

Field Summary

Fields

Modifier and Type	Field and Description
private AtomicReference<CellSet>	cellSet
private CellComparator	comparator
static long	DEEP_OVERHEAD
static long	FIXED_OVERHEAD
private MemStoreLAB	memStoreLAB
protected MemStoreSizing	memStoreSizing
protected long	minSequenceId
protected boolean	tagsPresent
protected TimeRangeTracker	timeRangeTracker

Fields inherited from interface org.apache.hadoop.hbase.regionserver.MemStoreSizing

DUD

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	Segment(CellComparator comparator, List<ImmutableSegment> segments, TimeRangeTracker trt)
protected	Segment(CellComparator comparator, TimeRangeTracker trt)
protected	Segment(CellSet cellSet, CellComparator comparator, MemStoreLAB memStoreLAB, TimeRangeTracker trt)
protected	Segment(Segment segment)

Method Summary

Modifier and Type	Method and Description
void	close() Closing a segment before it is being discarded
int	compare(Cell left, Cell right)
int	compareRows(Cell left, Cell right)
void	decScannerCount()
(package private) void	dump(org.slf4j.Logger log) Dumps all cells of the segment into the given log
(package private) static int	getCellLength(Cell cell) Get cell length after serialized in KeyValue
int	getCellsCount()
protected CellSet	getCellSet()
protected CellComparator	getComparator() Returns the Cell comparator used by this segment
long	getDataSize()
long	getHeapSize()
(package private) MemStoreLAB	getMemStoreLAB()
MemStoreSize	getMemStoreSize()
long	getMinSequenceId()
long	getOffHeapSize()
protected KeyValueScanner	getScanner(long readPoint) Creates the scanner for the given read point
List<KeyValueScanner>	getScanners(long readPoint)
TimeRangeTracker	getTimeRangeTracker()
SortedSet<Cell>	headSet(Cell firstKeyOnRow)
protected long	heapSizeChange(Cell cell, boolean succ)
long	incMemStoreSize(long delta, long heapOverhead, long offHeapOverhead)
void	incScannerCount()
protected long	indexEntryOffHeapSize(boolean offHeap)
protected long	indexEntryOnHeapSize(boolean onHeap)
protected abstract long	indexEntrySize()
protected void	internalAdd(Cell cell, boolean mslabUsed, MemStoreSizing memstoreSizing)
boolean	isEmpty()
boolean	isTagsPresent()
Iterator<Cell>	iterator()
Cell	last()
Cell	maybeCloneWithAllocator(Cell cell, boolean forceCloneOfBigCell) If the segment has a memory allocator the cell is being cloned to this space, and returned; otherwise the given cell is returned When a cell's size is too big (bigger than maxAlloc), it is not allocated on MSLAB.
protected long	offHeapSizeChange(Cell cell, boolean succ)
protected Segment	setCellSet(CellSet cellSetOld, CellSet cellSetNew) Setting the CellSet of the segment - used only for flat immutable segment for setting immutable CellSet after its creation in immutable segment constructor
boolean	shouldSeek(TimeRange tr, long oldestUnexpiredTS)
protected SortedSet<Cell>	tailSet(Cell firstCell) Returns a subset of the segment cell set, which starts with the given cell
String	toString()
protected void	updateMetaInfo(Cell cellToAdd, boolean succ, boolean mslabUsed, MemStoreSizing memstoreSizing)
protected void	updateMetaInfo(Cell cellToAdd, boolean succ, MemStoreSizing memstoreSizing)

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.apache.hadoop.hbase.regionserver.MemStoreSizing

decMemStoreSize, decMemStoreSize, incMemStoreSize

Field Detail

FIXED_OVERHEAD

public static final long FIXED_OVERHEAD

DEEP_OVERHEAD

public static final long DEEP_OVERHEAD

cellSet

private AtomicReference<CellSet> cellSet

comparator

private final CellComparator comparator

minSequenceId

protected long minSequenceId

memStoreLAB

private MemStoreLAB memStoreLAB

memStoreSizing

protected final MemStoreSizing memStoreSizing

timeRangeTracker

protected final TimeRangeTracker timeRangeTracker

tagsPresent

protected volatile boolean tagsPresent

Constructor Detail

Segment

protected Segment(CellComparator comparator,
                  TimeRangeTracker trt)

Segment

protected Segment(CellComparator comparator,
                  List<ImmutableSegment> segments,
                  TimeRangeTracker trt)

Segment

protected Segment(CellSet cellSet,
                  CellComparator comparator,
                  MemStoreLAB memStoreLAB,
                  TimeRangeTracker trt)

Segment

protected Segment(Segment segment)

Method Detail

getScanner

protected KeyValueScanner getScanner(long readPoint)

Creates the scanner for the given read point

Returns:

a scanner for the given read point

getScanners

public List<KeyValueScanner> getScanners(long readPoint)

isEmpty

public boolean isEmpty()

Returns:

whether the segment has any cells

getCellsCount

public int getCellsCount()

Returns:

number of cells in segment

close

public void close()

Closing a segment before it is being discarded

maybeCloneWithAllocator

public Cell maybeCloneWithAllocator(Cell cell,
                                    boolean forceCloneOfBigCell)

If the segment has a memory allocator the cell is being cloned to this space, and returned; otherwise the given cell is returned When a cell's size is too big (bigger than maxAlloc), it is not allocated on MSLAB. Since the process of flattening to CellChunkMap assumes that all cells are allocated on MSLAB, during this process, the input parameter forceCloneOfBigCell is set to 'true' and the cell is copied into MSLAB.

Returns:

either the given cell or its clone

getCellLength

static int getCellLength(Cell cell)

Get cell length after serialized in KeyValue

shouldSeek

public boolean shouldSeek(TimeRange tr,
                          long oldestUnexpiredTS)

isTagsPresent

public boolean isTagsPresent()

incScannerCount

public void incScannerCount()

decScannerCount

public void decScannerCount()

setCellSet

protected Segment setCellSet(CellSet cellSetOld,
                             CellSet cellSetNew)

Setting the CellSet of the segment - used only for flat immutable segment for setting immutable CellSet after its creation in immutable segment constructor

Returns:

this object

getMemStoreSize

public MemStoreSize getMemStoreSize()

Specified by:

getMemStoreSize in interface MemStoreSizing

Returns:

Use this datastructure to return all three settings, MemStoreSizing.getDataSize(), MemStoreSizing.getHeapSize(), and MemStoreSizing.getOffHeapSize(), in the one go.

getDataSize

public long getDataSize()

Specified by:

getDataSize in interface MemStoreSizing

getHeapSize

public long getHeapSize()

Specified by:

getHeapSize in interface MemStoreSizing

getOffHeapSize

public long getOffHeapSize()

Specified by:

getOffHeapSize in interface MemStoreSizing

incMemStoreSize

public long incMemStoreSize(long delta,
                            long heapOverhead,
                            long offHeapOverhead)

Specified by:

incMemStoreSize in interface MemStoreSizing

Returns:

The new dataSize ONLY as a convenience

getMinSequenceId

public long getMinSequenceId()

getTimeRangeTracker

public TimeRangeTracker getTimeRangeTracker()

last

public Cell last()

iterator

public Iterator<Cell> iterator()

headSet

public SortedSet<Cell> headSet(Cell firstKeyOnRow)

compare

public int compare(Cell left,
                   Cell right)

compareRows

public int compareRows(Cell left,
                       Cell right)

getCellSet

protected CellSet getCellSet()

Returns:

a set of all cells in the segment

getComparator

protected CellComparator getComparator()

Returns the Cell comparator used by this segment

Returns:

the Cell comparator used by this segment

internalAdd

protected void internalAdd(Cell cell,
                           boolean mslabUsed,
                           MemStoreSizing memstoreSizing)

updateMetaInfo

protected void updateMetaInfo(Cell cellToAdd,
                              boolean succ,
                              boolean mslabUsed,
                              MemStoreSizing memstoreSizing)

updateMetaInfo

protected void updateMetaInfo(Cell cellToAdd,
                              boolean succ,
                              MemStoreSizing memstoreSizing)

heapSizeChange

protected long heapSizeChange(Cell cell,
                              boolean succ)

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.

offHeapSizeChange

protected long offHeapSizeChange(Cell cell,
                                 boolean succ)

indexEntryOnHeapSize

protected long indexEntryOnHeapSize(boolean onHeap)

indexEntryOffHeapSize

protected long indexEntryOffHeapSize(boolean offHeap)

indexEntrySize

protected abstract long indexEntrySize()

tailSet

protected SortedSet<Cell> tailSet(Cell firstCell)

Returns a subset of the segment cell set, which starts with the given cell

Parameters:

firstCell - a cell in the segment

Returns:

a subset of the segment cell set, which starts with the given cell

getMemStoreLAB

MemStoreLAB getMemStoreLAB()

dump

void dump(org.slf4j.Logger log)

Dumps all cells of the segment into the given log

toString

public String toString()

Overrides:

toString in class Object