http://git-wip-us.apache.org/repos/asf/hbase-site/blob/3332caca/devapidocs/src-html/org/apache/hadoop/hbase/regionserver/HRegion.MutationBatch.html
----------------------------------------------------------------------
diff --git
a/devapidocs/src-html/org/apache/hadoop/hbase/regionserver/HRegion.MutationBatch.html
b/devapidocs/src-html/org/apache/hadoop/hbase/regionserver/HRegion.MutationBatch.html
index a0961f7..4a7f4ae 100644
---
a/devapidocs/src-html/org/apache/hadoop/hbase/regionserver/HRegion.MutationBatch.html
+++
b/devapidocs/src-html/org/apache/hadoop/hbase/regionserver/HRegion.MutationBatch.html
@@ -526,23 +526,23 @@
<span class="sourceLineNo">518</span> final FlushResultImpl result; //
indicating a failure result from prepare<a name="line.518"></a>
<span class="sourceLineNo">519</span> final TreeMap<byte[],
StoreFlushContext> storeFlushCtxs;<a name="line.519"></a>
<span class="sourceLineNo">520</span> final TreeMap<byte[],
List<Path>> committedFiles;<a name="line.520"></a>
-<span class="sourceLineNo">521</span> final TreeMap<byte[],
MemstoreSize> storeFlushableSize;<a name="line.521"></a>
+<span class="sourceLineNo">521</span> final TreeMap<byte[],
MemStoreSize> storeFlushableSize;<a name="line.521"></a>
<span class="sourceLineNo">522</span> final long startTime;<a
name="line.522"></a>
<span class="sourceLineNo">523</span> final long flushOpSeqId;<a
name="line.523"></a>
<span class="sourceLineNo">524</span> final long flushedSeqId;<a
name="line.524"></a>
-<span class="sourceLineNo">525</span> final MemstoreSize
totalFlushableSize;<a name="line.525"></a>
+<span class="sourceLineNo">525</span> final MemStoreSize
totalFlushableSize;<a name="line.525"></a>
<span class="sourceLineNo">526</span><a name="line.526"></a>
<span class="sourceLineNo">527</span> /** Constructs an early exit case
*/<a name="line.527"></a>
<span class="sourceLineNo">528</span> PrepareFlushResult(FlushResultImpl
result, long flushSeqId) {<a name="line.528"></a>
-<span class="sourceLineNo">529</span> this(result, null, null, null,
Math.max(0, flushSeqId), 0, 0, new MemstoreSize());<a name="line.529"></a>
+<span class="sourceLineNo">529</span> this(result, null, null, null,
Math.max(0, flushSeqId), 0, 0, new MemStoreSize());<a name="line.529"></a>
<span class="sourceLineNo">530</span> }<a name="line.530"></a>
<span class="sourceLineNo">531</span><a name="line.531"></a>
<span class="sourceLineNo">532</span> /** Constructs a successful prepare
flush result */<a name="line.532"></a>
<span class="sourceLineNo">533</span> PrepareFlushResult(<a
name="line.533"></a>
<span class="sourceLineNo">534</span> TreeMap<byte[],
StoreFlushContext> storeFlushCtxs,<a name="line.534"></a>
<span class="sourceLineNo">535</span> TreeMap<byte[],
List<Path>> committedFiles,<a name="line.535"></a>
-<span class="sourceLineNo">536</span> TreeMap<byte[], MemstoreSize>
storeFlushableSize, long startTime, long flushSeqId,<a name="line.536"></a>
-<span class="sourceLineNo">537</span> long flushedSeqId, MemstoreSize
totalFlushableSize) {<a name="line.537"></a>
+<span class="sourceLineNo">536</span> TreeMap<byte[], MemStoreSize>
storeFlushableSize, long startTime, long flushSeqId,<a name="line.536"></a>
+<span class="sourceLineNo">537</span> long flushedSeqId, MemStoreSize
totalFlushableSize) {<a name="line.537"></a>
<span class="sourceLineNo">538</span> this(null, storeFlushCtxs,
committedFiles, storeFlushableSize, startTime,<a name="line.538"></a>
<span class="sourceLineNo">539</span> flushSeqId, flushedSeqId,
totalFlushableSize);<a name="line.539"></a>
<span class="sourceLineNo">540</span> }<a name="line.540"></a>
@@ -551,8 +551,8 @@
<span class="sourceLineNo">543</span> FlushResultImpl result,<a
name="line.543"></a>
<span class="sourceLineNo">544</span> TreeMap<byte[],
StoreFlushContext> storeFlushCtxs,<a name="line.544"></a>
<span class="sourceLineNo">545</span> TreeMap<byte[],
List<Path>> committedFiles,<a name="line.545"></a>
-<span class="sourceLineNo">546</span> TreeMap<byte[], MemstoreSize>
storeFlushableSize, long startTime, long flushSeqId,<a name="line.546"></a>
-<span class="sourceLineNo">547</span> long flushedSeqId, MemstoreSize
totalFlushableSize) {<a name="line.547"></a>
+<span class="sourceLineNo">546</span> TreeMap<byte[], MemStoreSize>
storeFlushableSize, long startTime, long flushSeqId,<a name="line.546"></a>
+<span class="sourceLineNo">547</span> long flushedSeqId, MemStoreSize
totalFlushableSize) {<a name="line.547"></a>
<span class="sourceLineNo">548</span> this.result = result;<a
name="line.548"></a>
<span class="sourceLineNo">549</span> this.storeFlushCtxs =
storeFlushCtxs;<a name="line.549"></a>
<span class="sourceLineNo">550</span> this.committedFiles =
committedFiles;<a name="line.550"></a>
@@ -1015,7 +1015,7 @@
<span class="sourceLineNo">1007</span> Future<HStore> future =
completionService.take();<a name="line.1007"></a>
<span class="sourceLineNo">1008</span> HStore store = future.get();<a
name="line.1008"></a>
<span class="sourceLineNo">1009</span>
this.stores.put(store.getColumnFamilyDescriptor().getName(), store);<a
name="line.1009"></a>
-<span class="sourceLineNo">1010</span> if (store.isSloppyMemstore())
{<a name="line.1010"></a>
+<span class="sourceLineNo">1010</span> if (store.isSloppyMemStore())
{<a name="line.1010"></a>
<span class="sourceLineNo">1011</span> hasSloppyStores = true;<a
name="line.1011"></a>
<span class="sourceLineNo">1012</span> }<a name="line.1012"></a>
<span class="sourceLineNo">1013</span><a name="line.1013"></a>
@@ -1025,7 +1025,7 @@
<span class="sourceLineNo">1017</span> if (maxSeqId == -1 ||
storeMaxSequenceId > maxSeqId) {<a name="line.1017"></a>
<span class="sourceLineNo">1018</span> maxSeqId =
storeMaxSequenceId;<a name="line.1018"></a>
<span class="sourceLineNo">1019</span> }<a name="line.1019"></a>
-<span class="sourceLineNo">1020</span> long maxStoreMemstoreTS =
store.getMaxMemstoreTS().orElse(0L);<a name="line.1020"></a>
+<span class="sourceLineNo">1020</span> long maxStoreMemstoreTS =
store.getMaxMemStoreTS().orElse(0L);<a name="line.1020"></a>
<span class="sourceLineNo">1021</span> if (maxStoreMemstoreTS >
maxMemstoreTS) {<a name="line.1021"></a>
<span class="sourceLineNo">1022</span> maxMemstoreTS =
maxStoreMemstoreTS;<a name="line.1022"></a>
<span class="sourceLineNo">1023</span> }<a name="line.1023"></a>
@@ -1202,24 +1202,24 @@
<span class="sourceLineNo">1194</span> * store<a name="line.1194"></a>
<span class="sourceLineNo">1195</span> * @return the size of memstore in
this region<a name="line.1195"></a>
<span class="sourceLineNo">1196</span> */<a name="line.1196"></a>
-<span class="sourceLineNo">1197</span> public long
addAndGetMemstoreSize(MemstoreSize memstoreSize) {<a name="line.1197"></a>
+<span class="sourceLineNo">1197</span> public long
addAndGetMemStoreSize(MemStoreSize memstoreSize) {<a name="line.1197"></a>
<span class="sourceLineNo">1198</span> if (this.rsAccounting != null) {<a
name="line.1198"></a>
-<span class="sourceLineNo">1199</span>
rsAccounting.incGlobalMemstoreSize(memstoreSize);<a name="line.1199"></a>
+<span class="sourceLineNo">1199</span>
rsAccounting.incGlobalMemStoreSize(memstoreSize);<a name="line.1199"></a>
<span class="sourceLineNo">1200</span> }<a name="line.1200"></a>
<span class="sourceLineNo">1201</span> long size =
this.memstoreDataSize.addAndGet(memstoreSize.getDataSize());<a
name="line.1201"></a>
-<span class="sourceLineNo">1202</span> checkNegativeMemstoreDataSize(size,
memstoreSize.getDataSize());<a name="line.1202"></a>
+<span class="sourceLineNo">1202</span> checkNegativeMemStoreDataSize(size,
memstoreSize.getDataSize());<a name="line.1202"></a>
<span class="sourceLineNo">1203</span> return size;<a name="line.1203"></a>
<span class="sourceLineNo">1204</span> }<a name="line.1204"></a>
<span class="sourceLineNo">1205</span><a name="line.1205"></a>
-<span class="sourceLineNo">1206</span> public void
decrMemstoreSize(MemstoreSize memstoreSize) {<a name="line.1206"></a>
+<span class="sourceLineNo">1206</span> public void
decrMemStoreSize(MemStoreSize memstoreSize) {<a name="line.1206"></a>
<span class="sourceLineNo">1207</span> if (this.rsAccounting != null) {<a
name="line.1207"></a>
-<span class="sourceLineNo">1208</span>
rsAccounting.decGlobalMemstoreSize(memstoreSize);<a name="line.1208"></a>
+<span class="sourceLineNo">1208</span>
rsAccounting.decGlobalMemStoreSize(memstoreSize);<a name="line.1208"></a>
<span class="sourceLineNo">1209</span> }<a name="line.1209"></a>
<span class="sourceLineNo">1210</span> long size =
this.memstoreDataSize.addAndGet(-memstoreSize.getDataSize());<a
name="line.1210"></a>
-<span class="sourceLineNo">1211</span> checkNegativeMemstoreDataSize(size,
-memstoreSize.getDataSize());<a name="line.1211"></a>
+<span class="sourceLineNo">1211</span> checkNegativeMemStoreDataSize(size,
-memstoreSize.getDataSize());<a name="line.1211"></a>
<span class="sourceLineNo">1212</span> }<a name="line.1212"></a>
<span class="sourceLineNo">1213</span><a name="line.1213"></a>
-<span class="sourceLineNo">1214</span> private void
checkNegativeMemstoreDataSize(long memstoreDataSize, long delta) {<a
name="line.1214"></a>
+<span class="sourceLineNo">1214</span> private void
checkNegativeMemStoreDataSize(long memstoreDataSize, long delta) {<a
name="line.1214"></a>
<span class="sourceLineNo">1215</span> // This is extremely bad if we make
memstoreSize negative. Log as much info on the offending<a name="line.1215"></a>
<span class="sourceLineNo">1216</span> // caller as possible. (memStoreSize
might be a negative value already -- freeing memory)<a name="line.1216"></a>
<span class="sourceLineNo">1217</span> if (memstoreDataSize < 0) {<a
name="line.1217"></a>
@@ -1268,7 +1268,7 @@
<span class="sourceLineNo">1260</span> }<a name="line.1260"></a>
<span class="sourceLineNo">1261</span><a name="line.1261"></a>
<span class="sourceLineNo">1262</span> @Override<a name="line.1262"></a>
-<span class="sourceLineNo">1263</span> public long getMemstoreSize() {<a
name="line.1263"></a>
+<span class="sourceLineNo">1263</span> public long getMemStoreSize() {<a
name="line.1263"></a>
<span class="sourceLineNo">1264</span> return memstoreDataSize.get();<a
name="line.1264"></a>
<span class="sourceLineNo">1265</span> }<a name="line.1265"></a>
<span class="sourceLineNo">1266</span><a name="line.1266"></a>
@@ -1653,13 +1653,13 @@
<span class="sourceLineNo">1645</span><a name="line.1645"></a>
<span class="sourceLineNo">1646</span> // close each store in
parallel<a name="line.1646"></a>
<span class="sourceLineNo">1647</span> for (HStore store :
stores.values()) {<a name="line.1647"></a>
-<span class="sourceLineNo">1648</span> MemstoreSize flushableSize =
store.getFlushableSize();<a name="line.1648"></a>
+<span class="sourceLineNo">1648</span> MemStoreSize flushableSize =
store.getFlushableSize();<a name="line.1648"></a>
<span class="sourceLineNo">1649</span> if (!(abort ||
flushableSize.getDataSize() == 0 || writestate.readOnly)) {<a
name="line.1649"></a>
<span class="sourceLineNo">1650</span> if
(getRegionServerServices() != null) {<a name="line.1650"></a>
<span class="sourceLineNo">1651</span>
getRegionServerServices().abort("Assertion failed while closing store "<a
name="line.1651"></a>
<span class="sourceLineNo">1652</span> +
getRegionInfo().getRegionNameAsString() + " " + store<a name="line.1652"></a>
<span class="sourceLineNo">1653</span> + ". flushableSize
expected=0, actual= " + flushableSize<a name="line.1653"></a>
-<span class="sourceLineNo">1654</span> + ". Current
memstoreSize=" + getMemstoreSize() + ". Maybe a coprocessor "<a
name="line.1654"></a>
+<span class="sourceLineNo">1654</span> + ". Current
memstoreSize=" + getMemStoreSize() + ". Maybe a coprocessor "<a
name="line.1654"></a>
<span class="sourceLineNo">1655</span> + "operation failed and
left the memstore in a partially updated state.", null);<a name="line.1655"></a>
<span class="sourceLineNo">1656</span> }<a name="line.1656"></a>
<span class="sourceLineNo">1657</span> }<a name="line.1657"></a>
@@ -1702,7 +1702,7 @@
<span class="sourceLineNo">1694</span><a name="line.1694"></a>
<span class="sourceLineNo">1695</span> this.closed.set(true);<a
name="line.1695"></a>
<span class="sourceLineNo">1696</span> if (!canFlush) {<a
name="line.1696"></a>
-<span class="sourceLineNo">1697</span> this.decrMemstoreSize(new
MemstoreSize(memstoreDataSize.get(), getMemstoreHeapSize()));<a
name="line.1697"></a>
+<span class="sourceLineNo">1697</span> this.decrMemStoreSize(new
MemStoreSize(memstoreDataSize.get(), getMemStoreHeapSize()));<a
name="line.1697"></a>
<span class="sourceLineNo">1698</span> } else if (memstoreDataSize.get()
!= 0) {<a name="line.1698"></a>
<span class="sourceLineNo">1699</span> LOG.error("Memstore size is " +
memstoreDataSize.get());<a name="line.1699"></a>
<span class="sourceLineNo">1700</span> }<a name="line.1700"></a>
@@ -1724,7 +1724,7 @@
<span class="sourceLineNo">1716</span> }<a name="line.1716"></a>
<span class="sourceLineNo">1717</span> }<a name="line.1717"></a>
<span class="sourceLineNo">1718</span><a name="line.1718"></a>
-<span class="sourceLineNo">1719</span> private long getMemstoreHeapSize() {<a
name="line.1719"></a>
+<span class="sourceLineNo">1719</span> private long getMemStoreHeapSize() {<a
name="line.1719"></a>
<span class="sourceLineNo">1720</span> return
stores.values().stream().mapToLong(s ->
s.getMemStoreSize().getHeapSize()).sum();<a name="line.1720"></a>
<span class="sourceLineNo">1721</span> }<a name="line.1721"></a>
<span class="sourceLineNo">1722</span><a name="line.1722"></a>
@@ -1914,7 +1914,7 @@
<span class="sourceLineNo">1906</span> byte[] encodedRegionName =
this.getRegionInfo().getEncodedNameAsBytes();<a name="line.1906"></a>
<span class="sourceLineNo">1907</span>
regionLoadBldr.clearStoreCompleteSequenceId();<a name="line.1907"></a>
<span class="sourceLineNo">1908</span> for (byte[] familyName :
this.stores.keySet()) {<a name="line.1908"></a>
-<span class="sourceLineNo">1909</span> long earliest =
this.wal.getEarliestMemstoreSeqNum(encodedRegionName, familyName);<a
name="line.1909"></a>
+<span class="sourceLineNo">1909</span> long earliest =
this.wal.getEarliestMemStoreSeqNum(encodedRegionName, familyName);<a
name="line.1909"></a>
<span class="sourceLineNo">1910</span> // Subtract - 1 to go earlier than
the current oldest, unflushed edit in memstore; this will<a
name="line.1910"></a>
<span class="sourceLineNo">1911</span> // give us a sequence id that is
for sure flushed. We want edit replay to start after this<a
name="line.1911"></a>
<span class="sourceLineNo">1912</span> // sequence id in this region. If
NO_SEQNUM, use the regions maximum flush id.<a name="line.1912"></a>
@@ -2277,7 +2277,7 @@
<span class="sourceLineNo">2269</span> * returns true which will make a lot
of flush requests.<a name="line.2269"></a>
<span class="sourceLineNo">2270</span> */<a name="line.2270"></a>
<span class="sourceLineNo">2271</span> boolean shouldFlushStore(HStore store)
{<a name="line.2271"></a>
-<span class="sourceLineNo">2272</span> long earliest =
this.wal.getEarliestMemstoreSeqNum(getRegionInfo().getEncodedNameAsBytes(),<a
name="line.2272"></a>
+<span class="sourceLineNo">2272</span> long earliest =
this.wal.getEarliestMemStoreSeqNum(getRegionInfo().getEncodedNameAsBytes(),<a
name="line.2272"></a>
<span class="sourceLineNo">2273</span>
store.getColumnFamilyDescriptor().getName()) - 1;<a name="line.2273"></a>
<span class="sourceLineNo">2274</span> if (earliest > 0 &&
earliest + flushPerChanges < mvcc.getReadPoint()) {<a name="line.2274"></a>
<span class="sourceLineNo">2275</span> if (LOG.isDebugEnabled()) {<a
name="line.2275"></a>
@@ -2447,7 +2447,7 @@
<span class="sourceLineNo">2439</span> // block waiting for the lock for
internal flush<a name="line.2439"></a>
<span class="sourceLineNo">2440</span>
this.updatesLock.writeLock().lock();<a name="line.2440"></a>
<span class="sourceLineNo">2441</span> status.setStatus("Preparing flush
snapshotting stores in " + getRegionInfo().getEncodedName());<a
name="line.2441"></a>
-<span class="sourceLineNo">2442</span> MemstoreSize
totalSizeOfFlushableStores = new MemstoreSize();<a name="line.2442"></a>
+<span class="sourceLineNo">2442</span> MemStoreSize
totalSizeOfFlushableStores = new MemStoreSize();<a name="line.2442"></a>
<span class="sourceLineNo">2443</span><a name="line.2443"></a>
<span class="sourceLineNo">2444</span> Map<byte[], Long>
flushedFamilyNamesToSeq = new HashMap<>();<a name="line.2444"></a>
<span class="sourceLineNo">2445</span> for (HStore store : storesToFlush)
{<a name="line.2445"></a>
@@ -2457,7 +2457,7 @@
<span class="sourceLineNo">2449</span><a name="line.2449"></a>
<span class="sourceLineNo">2450</span> TreeMap<byte[],
StoreFlushContext> storeFlushCtxs = new
TreeMap<>(Bytes.BYTES_COMPARATOR);<a name="line.2450"></a>
<span class="sourceLineNo">2451</span> TreeMap<byte[],
List<Path>> committedFiles = new
TreeMap<>(Bytes.BYTES_COMPARATOR);<a name="line.2451"></a>
-<span class="sourceLineNo">2452</span> TreeMap<byte[], MemstoreSize>
storeFlushableSize = new TreeMap<>(Bytes.BYTES_COMPARATOR);<a
name="line.2452"></a>
+<span class="sourceLineNo">2452</span> TreeMap<byte[], MemStoreSize>
storeFlushableSize = new TreeMap<>(Bytes.BYTES_COMPARATOR);<a
name="line.2452"></a>
<span class="sourceLineNo">2453</span> // The sequence id of this flush
operation which is used to log FlushMarker and pass to<a name="line.2453"></a>
<span class="sourceLineNo">2454</span> // createFlushContext to use as the
store file's sequence id. It can be in advance of edits<a name="line.2454"></a>
<span class="sourceLineNo">2455</span> // still in the memstore, edits that
are in other column families yet to be flushed.<a name="line.2455"></a>
@@ -2489,8 +2489,8 @@
<span class="sourceLineNo">2481</span> }<a name="line.2481"></a>
<span class="sourceLineNo">2482</span><a name="line.2482"></a>
<span class="sourceLineNo">2483</span> for (HStore s : storesToFlush) {<a
name="line.2483"></a>
-<span class="sourceLineNo">2484</span> MemstoreSize flushableSize =
s.getFlushableSize();<a name="line.2484"></a>
-<span class="sourceLineNo">2485</span>
totalSizeOfFlushableStores.incMemstoreSize(flushableSize);<a
name="line.2485"></a>
+<span class="sourceLineNo">2484</span> MemStoreSize flushableSize =
s.getFlushableSize();<a name="line.2484"></a>
+<span class="sourceLineNo">2485</span>
totalSizeOfFlushableStores.incMemStoreSize(flushableSize);<a
name="line.2485"></a>
<span class="sourceLineNo">2486</span>
storeFlushCtxs.put(s.getColumnFamilyDescriptor().getName(),
s.createFlushContext(flushOpSeqId));<a name="line.2486"></a>
<span class="sourceLineNo">2487</span>
committedFiles.put(s.getColumnFamilyDescriptor().getName(), null); // for
writing stores to WAL<a name="line.2487"></a>
<span class="sourceLineNo">2488</span>
storeFlushableSize.put(s.getColumnFamilyDescriptor().getName(),
flushableSize);<a name="line.2488"></a>
@@ -2653,15 +2653,15 @@
<span class="sourceLineNo">2645</span> committedFiles.put(storeName,
storeCommittedFiles);<a name="line.2645"></a>
<span class="sourceLineNo">2646</span> // Flush committed no files,
indicating flush is empty or flush was canceled<a name="line.2646"></a>
<span class="sourceLineNo">2647</span> if (storeCommittedFiles == null
|| storeCommittedFiles.isEmpty()) {<a name="line.2647"></a>
-<span class="sourceLineNo">2648</span> MemstoreSize
storeFlushableSize = prepareResult.storeFlushableSize.get(storeName);<a
name="line.2648"></a>
-<span class="sourceLineNo">2649</span>
prepareResult.totalFlushableSize.decMemstoreSize(storeFlushableSize);<a
name="line.2649"></a>
+<span class="sourceLineNo">2648</span> MemStoreSize
storeFlushableSize = prepareResult.storeFlushableSize.get(storeName);<a
name="line.2648"></a>
+<span class="sourceLineNo">2649</span>
prepareResult.totalFlushableSize.decMemStoreSize(storeFlushableSize);<a
name="line.2649"></a>
<span class="sourceLineNo">2650</span> }<a name="line.2650"></a>
<span class="sourceLineNo">2651</span> flushedOutputFileSize +=
flush.getOutputFileSize();<a name="line.2651"></a>
<span class="sourceLineNo">2652</span> }<a name="line.2652"></a>
<span class="sourceLineNo">2653</span> storeFlushCtxs.clear();<a
name="line.2653"></a>
<span class="sourceLineNo">2654</span><a name="line.2654"></a>
<span class="sourceLineNo">2655</span> // Set down the memstore size by
amount of flush.<a name="line.2655"></a>
-<span class="sourceLineNo">2656</span>
this.decrMemstoreSize(prepareResult.totalFlushableSize);<a name="line.2656"></a>
+<span class="sourceLineNo">2656</span>
this.decrMemStoreSize(prepareResult.totalFlushableSize);<a name="line.2656"></a>
<span class="sourceLineNo">2657</span><a name="line.2657"></a>
<span class="sourceLineNo">2658</span> if (wal != null) {<a
name="line.2658"></a>
<span class="sourceLineNo">2659</span> // write flush marker to WAL. If
fail, we should throw DroppedSnapshotException<a name="line.2659"></a>
@@ -3118,7 +3118,7 @@
<span class="sourceLineNo">3110</span> initialized = true;<a
name="line.3110"></a>
<span class="sourceLineNo">3111</span> }<a name="line.3111"></a>
<span class="sourceLineNo">3112</span> doMiniBatchMutate(batchOp);<a
name="line.3112"></a>
-<span class="sourceLineNo">3113</span> long newSize =
this.getMemstoreSize();<a name="line.3113"></a>
+<span class="sourceLineNo">3113</span> long newSize =
this.getMemStoreSize();<a name="line.3113"></a>
<span class="sourceLineNo">3114</span> requestFlushIfNeeded(newSize);<a
name="line.3114"></a>
<span class="sourceLineNo">3115</span> }<a name="line.3115"></a>
<span class="sourceLineNo">3116</span> } finally {<a name="line.3116"></a>
@@ -3190,7 +3190,7 @@
<span class="sourceLineNo">3182</span> int cellCount = 0;<a
name="line.3182"></a>
<span class="sourceLineNo">3183</span> /** Keep track of the locks we hold
so we can release them in finally clause */<a name="line.3183"></a>
<span class="sourceLineNo">3184</span> List<RowLock> acquiredRowLocks
= Lists.newArrayListWithCapacity(batchOp.operations.length);<a
name="line.3184"></a>
-<span class="sourceLineNo">3185</span> MemstoreSize memstoreSize = new
MemstoreSize();<a name="line.3185"></a>
+<span class="sourceLineNo">3185</span> MemStoreSize memstoreSize = new
MemStoreSize();<a name="line.3185"></a>
<span class="sourceLineNo">3186</span> final ObservedExceptionsInBatch
observedExceptions = new ObservedExceptionsInBatch();<a name="line.3186"></a>
<span class="sourceLineNo">3187</span> try {<a name="line.3187"></a>
<span class="sourceLineNo">3188</span> // STEP 1. Try to acquire as many
locks as we can, and ensure we acquire at least one.<a name="line.3188"></a>
@@ -3422,11 +3422,11 @@
<span class="sourceLineNo">3414</span>
this.updateSequenceId(familyMaps[i].values(),<a name="line.3414"></a>
<span class="sourceLineNo">3415</span> replay?
batchOp.getReplaySequenceId(): writeEntry.getWriteNumber());<a
name="line.3415"></a>
<span class="sourceLineNo">3416</span> }<a name="line.3416"></a>
-<span class="sourceLineNo">3417</span>
applyFamilyMapToMemstore(familyMaps[i], memstoreSize);<a name="line.3417"></a>
+<span class="sourceLineNo">3417</span>
applyFamilyMapToMemStore(familyMaps[i], memstoreSize);<a name="line.3417"></a>
<span class="sourceLineNo">3418</span> }<a name="line.3418"></a>
<span class="sourceLineNo">3419</span><a name="line.3419"></a>
<span class="sourceLineNo">3420</span> // update memstore size<a
name="line.3420"></a>
-<span class="sourceLineNo">3421</span>
this.addAndGetMemstoreSize(memstoreSize);<a name="line.3421"></a>
+<span class="sourceLineNo">3421</span>
this.addAndGetMemStoreSize(memstoreSize);<a name="line.3421"></a>
<span class="sourceLineNo">3422</span><a name="line.3422"></a>
<span class="sourceLineNo">3423</span> // calling the post CP hook for
batch mutation<a name="line.3423"></a>
<span class="sourceLineNo">3424</span> if (!replay &&
coprocessorHost != null) {<a name="line.3424"></a>
@@ -3960,13 +3960,13 @@
<span class="sourceLineNo">3952</span> * @param familyMap Map of Cells by
family<a name="line.3952"></a>
<span class="sourceLineNo">3953</span> * @param memstoreSize<a
name="line.3953"></a>
<span class="sourceLineNo">3954</span> */<a name="line.3954"></a>
-<span class="sourceLineNo">3955</span> private void
applyFamilyMapToMemstore(Map<byte[], List<Cell>> familyMap,<a
name="line.3955"></a>
-<span class="sourceLineNo">3956</span> MemstoreSize memstoreSize) throws
IOException {<a name="line.3956"></a>
+<span class="sourceLineNo">3955</span> private void
applyFamilyMapToMemStore(Map<byte[], List<Cell>> familyMap,<a
name="line.3955"></a>
+<span class="sourceLineNo">3956</span> MemStoreSize memstoreSize) throws
IOException {<a name="line.3956"></a>
<span class="sourceLineNo">3957</span> for (Map.Entry<byte[],
List<Cell>> e : familyMap.entrySet()) {<a name="line.3957"></a>
<span class="sourceLineNo">3958</span> byte[] family = e.getKey();<a
name="line.3958"></a>
<span class="sourceLineNo">3959</span> List<Cell> cells =
e.getValue();<a name="line.3959"></a>
<span class="sourceLineNo">3960</span> assert cells instanceof
RandomAccess;<a name="line.3960"></a>
-<span class="sourceLineNo">3961</span> applyToMemstore(getStore(family),
cells, false, memstoreSize);<a name="line.3961"></a>
+<span class="sourceLineNo">3961</span> applyToMemStore(getStore(family),
cells, false, memstoreSize);<a name="line.3961"></a>
<span class="sourceLineNo">3962</span> }<a name="line.3962"></a>
<span class="sourceLineNo">3963</span> }<a name="line.3963"></a>
<span class="sourceLineNo">3964</span><a name="line.3964"></a>
@@ -3974,11 +3974,11 @@
<span class="sourceLineNo">3966</span> * @param delta If we are doing delta
changes -- e.g. increment/append -- then this flag will be<a
name="line.3966"></a>
<span class="sourceLineNo">3967</span> * set; when set we will run
operations that make sense in the increment/append scenario<a
name="line.3967"></a>
<span class="sourceLineNo">3968</span> * but that do not make sense
otherwise.<a name="line.3968"></a>
-<span class="sourceLineNo">3969</span> * @see #applyToMemstore(HStore, Cell,
long)<a name="line.3969"></a>
+<span class="sourceLineNo">3969</span> * @see #applyToMemStore(HStore, Cell,
MemStoreSize)<a name="line.3969"></a>
<span class="sourceLineNo">3970</span> */<a name="line.3970"></a>
-<span class="sourceLineNo">3971</span> private void applyToMemstore(HStore
store, List<Cell> cells, boolean delta,<a name="line.3971"></a>
-<span class="sourceLineNo">3972</span> MemstoreSize memstoreSize) throws
IOException {<a name="line.3972"></a>
-<span class="sourceLineNo">3973</span> // Any change in how we update
Store/MemStore needs to also be done in other applyToMemstore!!!!<a
name="line.3973"></a>
+<span class="sourceLineNo">3971</span> private void applyToMemStore(HStore
store, List<Cell> cells, boolean delta,<a name="line.3971"></a>
+<span class="sourceLineNo">3972</span> MemStoreSize memstoreSize) throws
IOException {<a name="line.3972"></a>
+<span class="sourceLineNo">3973</span> // Any change in how we update
Store/MemStore needs to also be done in other applyToMemStore!!!!<a
name="line.3973"></a>
<span class="sourceLineNo">3974</span> boolean upsert = delta &&
store.getColumnFamilyDescriptor().getMaxVersions() == 1;<a name="line.3974"></a>
<span class="sourceLineNo">3975</span> if (upsert) {<a name="line.3975"></a>
<span class="sourceLineNo">3976</span> store.upsert(cells,
getSmallestReadPoint(), memstoreSize);<a name="line.3976"></a>
@@ -3988,11 +3988,11 @@
<span class="sourceLineNo">3980</span> }<a name="line.3980"></a>
<span class="sourceLineNo">3981</span><a name="line.3981"></a>
<span class="sourceLineNo">3982</span> /**<a name="line.3982"></a>
-<span class="sourceLineNo">3983</span> * @see #applyToMemstore(HStore, List,
boolean, boolean, long)<a name="line.3983"></a>
+<span class="sourceLineNo">3983</span> * @see #applyToMemStore(HStore, List,
boolean, MemStoreSize)<a name="line.3983"></a>
<span class="sourceLineNo">3984</span> */<a name="line.3984"></a>
-<span class="sourceLineNo">3985</span> private void applyToMemstore(HStore
store, Cell cell, MemstoreSize memstoreSize)<a name="line.3985"></a>
+<span class="sourceLineNo">3985</span> private void applyToMemStore(HStore
store, Cell cell, MemStoreSize memstoreSize)<a name="line.3985"></a>
<span class="sourceLineNo">3986</span> throws IOException {<a
name="line.3986"></a>
-<span class="sourceLineNo">3987</span> // Any change in how we update
Store/MemStore needs to also be done in other applyToMemstore!!!!<a
name="line.3987"></a>
+<span class="sourceLineNo">3987</span> // Any change in how we update
Store/MemStore needs to also be done in other applyToMemStore!!!!<a
name="line.3987"></a>
<span class="sourceLineNo">3988</span> if (store == null) {<a
name="line.3988"></a>
<span class="sourceLineNo">3989</span>
checkFamily(CellUtil.cloneFamily(cell));<a name="line.3989"></a>
<span class="sourceLineNo">3990</span> // Unreachable because checkFamily
will throw exception<a name="line.3990"></a>
@@ -4048,7 +4048,7 @@
<span class="sourceLineNo">4040</span> }<a name="line.4040"></a>
<span class="sourceLineNo">4041</span><a name="line.4041"></a>
<span class="sourceLineNo">4042</span> private void requestFlushIfNeeded(long
memstoreTotalSize) throws RegionTooBusyException {<a name="line.4042"></a>
-<span class="sourceLineNo">4043</span> if(memstoreTotalSize >
this.getMemstoreFlushSize()) {<a name="line.4043"></a>
+<span class="sourceLineNo">4043</span> if(memstoreTotalSize >
this.getMemStoreFlushSize()) {<a name="line.4043"></a>
<span class="sourceLineNo">4044</span> requestFlush();<a
name="line.4044"></a>
<span class="sourceLineNo">4045</span> }<a name="line.4045"></a>
<span class="sourceLineNo">4046</span> }<a name="line.4046"></a>
@@ -4316,7 +4316,7 @@
<span class="sourceLineNo">4308</span> }<a name="line.4308"></a>
<span class="sourceLineNo">4309</span><a name="line.4309"></a>
<span class="sourceLineNo">4310</span> boolean flush = false;<a
name="line.4310"></a>
-<span class="sourceLineNo">4311</span> MemstoreSize memstoreSize =
new MemstoreSize();<a name="line.4311"></a>
+<span class="sourceLineNo">4311</span> MemStoreSize memstoreSize =
new MemStoreSize();<a name="line.4311"></a>
<span class="sourceLineNo">4312</span> for (Cell cell:
val.getCells()) {<a name="line.4312"></a>
<span class="sourceLineNo">4313</span> // Check this edit is for
me. Also, guard against writing the special<a name="line.4313"></a>
<span class="sourceLineNo">4314</span> // METACOLUMN info such as
HBASE::CACHEFLUSH entries<a name="line.4314"></a>
@@ -4366,7 +4366,7 @@
<span class="sourceLineNo">4358</span>
rsAccounting.addRegionReplayEditsSize(getRegionInfo().getRegionName(),<a
name="line.4358"></a>
<span class="sourceLineNo">4359</span> memstoreSize);<a
name="line.4359"></a>
<span class="sourceLineNo">4360</span> }<a name="line.4360"></a>
-<span class="sourceLineNo">4361</span> flush =
isFlushSize(this.addAndGetMemstoreSize(memstoreSize));<a name="line.4361"></a>
+<span class="sourceLineNo">4361</span> flush =
isFlushSize(this.addAndGetMemStoreSize(memstoreSize));<a name="line.4361"></a>
<span class="sourceLineNo">4362</span> if (flush) {<a
name="line.4362"></a>
<span class="sourceLineNo">4363</span> internalFlushcache(null,
currentEditSeqId, stores.values(), status, false);<a name="line.4363"></a>
<span class="sourceLineNo">4364</span> }<a name="line.4364"></a>
@@ -4675,7 +4675,7 @@
<span class="sourceLineNo">4667</span> replayFlushInStores(flush,
prepareFlushResult, true);<a name="line.4667"></a>
<span class="sourceLineNo">4668</span><a name="line.4668"></a>
<span class="sourceLineNo">4669</span> // Set down the memstore
size by amount of flush.<a name="line.4669"></a>
-<span class="sourceLineNo">4670</span>
this.decrMemstoreSize(prepareFlushResult.totalFlushableSize);<a
name="line.4670"></a>
+<span class="sourceLineNo">4670</span>
this.decrMemStoreSize(prepareFlushResult.totalFlushableSize);<a
name="line.4670"></a>
<span class="sourceLineNo">4671</span><a name="line.4671"></a>
<span class="sourceLineNo">4672</span> this.prepareFlushResult =
null;<a name="line.4672"></a>
<span class="sourceLineNo">4673</span> writestate.flushing =
false;<a name="line.4673"></a>
@@ -4708,11 +4708,11 @@
<span class="sourceLineNo">4700</span> replayFlushInStores(flush,
prepareFlushResult, true);<a name="line.4700"></a>
<span class="sourceLineNo">4701</span><a name="line.4701"></a>
<span class="sourceLineNo">4702</span> // Set down the memstore
size by amount of flush.<a name="line.4702"></a>
-<span class="sourceLineNo">4703</span>
this.decrMemstoreSize(prepareFlushResult.totalFlushableSize);<a
name="line.4703"></a>
+<span class="sourceLineNo">4703</span>
this.decrMemStoreSize(prepareFlushResult.totalFlushableSize);<a
name="line.4703"></a>
<span class="sourceLineNo">4704</span><a name="line.4704"></a>
<span class="sourceLineNo">4705</span> // Inspect the memstore
contents to see whether the memstore contains only edits<a name="line.4705"></a>
<span class="sourceLineNo">4706</span> // with seqId smaller than
the flush seqId. If so, we can discard those edits.<a name="line.4706"></a>
-<span class="sourceLineNo">4707</span>
dropMemstoreContentsForSeqId(flush.getFlushSequenceNumber(), null);<a
name="line.4707"></a>
+<span class="sourceLineNo">4707</span>
dropMemStoreContentsForSeqId(flush.getFlushSequenceNumber(), null);<a
name="line.4707"></a>
<span class="sourceLineNo">4708</span><a name="line.4708"></a>
<span class="sourceLineNo">4709</span> this.prepareFlushResult =
null;<a name="line.4709"></a>
<span class="sourceLineNo">4710</span> writestate.flushing =
false;<a name="line.4710"></a>
@@ -4733,7 +4733,7 @@
<span class="sourceLineNo">4725</span><a name="line.4725"></a>
<span class="sourceLineNo">4726</span> // Inspect the memstore
contents to see whether the memstore contains only edits<a name="line.4726"></a>
<span class="sourceLineNo">4727</span> // with seqId smaller than the
flush seqId. If so, we can discard those edits.<a name="line.4727"></a>
-<span class="sourceLineNo">4728</span>
dropMemstoreContentsForSeqId(flush.getFlushSequenceNumber(), null);<a
name="line.4728"></a>
+<span class="sourceLineNo">4728</span>
dropMemStoreContentsForSeqId(flush.getFlushSequenceNumber(), null);<a
name="line.4728"></a>
<span class="sourceLineNo">4729</span> }<a name="line.4729"></a>
<span class="sourceLineNo">4730</span><a name="line.4730"></a>
<span class="sourceLineNo">4731</span> status.markComplete("Flush
commit successful");<a name="line.4731"></a>
@@ -4811,8 +4811,8 @@
<span class="sourceLineNo">4803</span> * if the memstore edits have seqNums
smaller than the given seq id<a name="line.4803"></a>
<span class="sourceLineNo">4804</span> * @throws IOException<a
name="line.4804"></a>
<span class="sourceLineNo">4805</span> */<a name="line.4805"></a>
-<span class="sourceLineNo">4806</span> private MemstoreSize
dropMemstoreContentsForSeqId(long seqId, HStore store) throws IOException {<a
name="line.4806"></a>
-<span class="sourceLineNo">4807</span> MemstoreSize totalFreedSize = new
MemstoreSize();<a name="line.4807"></a>
+<span class="sourceLineNo">4806</span> private MemStoreSize
dropMemStoreContentsForSeqId(long seqId, HStore store) throws IOException {<a
name="line.4806"></a>
+<span class="sourceLineNo">4807</span> MemStoreSize totalFreedSize = new
MemStoreSize();<a name="line.4807"></a>
<span class="sourceLineNo">4808</span>
this.updatesLock.writeLock().lock();<a name="line.4808"></a>
<span class="sourceLineNo">4809</span> try {<a name="line.4809"></a>
<span class="sourceLineNo">4810</span><a name="line.4810"></a>
@@ -4826,10 +4826,10 @@
<span class="sourceLineNo">4818</span> // Prepare flush (take a
snapshot) and then abort (drop the snapshot)<a name="line.4818"></a>
<span class="sourceLineNo">4819</span> if (store == null) {<a
name="line.4819"></a>
<span class="sourceLineNo">4820</span> for (HStore s :
stores.values()) {<a name="line.4820"></a>
-<span class="sourceLineNo">4821</span>
totalFreedSize.incMemstoreSize(doDropStoreMemstoreContentsForSeqId(s,
currentSeqId));<a name="line.4821"></a>
+<span class="sourceLineNo">4821</span>
totalFreedSize.incMemStoreSize(doDropStoreMemStoreContentsForSeqId(s,
currentSeqId));<a name="line.4821"></a>
<span class="sourceLineNo">4822</span> }<a name="line.4822"></a>
<span class="sourceLineNo">4823</span> } else {<a name="line.4823"></a>
-<span class="sourceLineNo">4824</span>
totalFreedSize.incMemstoreSize(doDropStoreMemstoreContentsForSeqId(store,
currentSeqId));<a name="line.4824"></a>
+<span class="sourceLineNo">4824</span>
totalFreedSize.incMemStoreSize(doDropStoreMemStoreContentsForSeqId(store,
currentSeqId));<a name="line.4824"></a>
<span class="sourceLineNo">4825</span> }<a name="line.4825"></a>
<span class="sourceLineNo">4826</span> } else {<a name="line.4826"></a>
<span class="sourceLineNo">4827</span>
LOG.info(getRegionInfo().getEncodedName() + " : "<a name="line.4827"></a>
@@ -4842,10 +4842,10 @@
<span class="sourceLineNo">4834</span> return totalFreedSize;<a
name="line.4834"></a>
<span class="sourceLineNo">4835</span> }<a name="line.4835"></a>
<span class="sourceLineNo">4836</span><a name="line.4836"></a>
-<span class="sourceLineNo">4837</span> private MemstoreSize
doDropStoreMemstoreContentsForSeqId(HStore s, long currentSeqId)<a
name="line.4837"></a>
+<span class="sourceLineNo">4837</span> private MemStoreSize
doDropStoreMemStoreContentsForSeqId(HStore s, long currentSeqId)<a
name="line.4837"></a>
<span class="sourceLineNo">4838</span> throws IOException {<a
name="line.4838"></a>
-<span class="sourceLineNo">4839</span> MemstoreSize flushableSize =
s.getFlushableSize();<a name="line.4839"></a>
-<span class="sourceLineNo">4840</span>
this.decrMemstoreSize(flushableSize);<a name="line.4840"></a>
+<span class="sourceLineNo">4839</span> MemStoreSize flushableSize =
s.getFlushableSize();<a name="line.4839"></a>
+<span class="sourceLineNo">4840</span>
this.decrMemStoreSize(flushableSize);<a name="line.4840"></a>
<span class="sourceLineNo">4841</span> StoreFlushContext ctx =
s.createFlushContext(currentSeqId);<a name="line.4841"></a>
<span class="sourceLineNo">4842</span> ctx.prepare();<a
name="line.4842"></a>
<span class="sourceLineNo">4843</span> ctx.abort();<a name="line.4843"></a>
@@ -4962,16 +4962,16 @@
<span class="sourceLineNo">4954</span> StoreFlushContext ctx =
this.prepareFlushResult.storeFlushCtxs == null ?<a name="line.4954"></a>
<span class="sourceLineNo">4955</span> null :
this.prepareFlushResult.storeFlushCtxs.get(family);<a name="line.4955"></a>
<span class="sourceLineNo">4956</span> if (ctx != null) {<a
name="line.4956"></a>
-<span class="sourceLineNo">4957</span> MemstoreSize
snapshotSize = store.getFlushableSize();<a name="line.4957"></a>
+<span class="sourceLineNo">4957</span> MemStoreSize
snapshotSize = store.getFlushableSize();<a name="line.4957"></a>
<span class="sourceLineNo">4958</span> ctx.abort();<a
name="line.4958"></a>
-<span class="sourceLineNo">4959</span>
this.decrMemstoreSize(snapshotSize);<a name="line.4959"></a>
+<span class="sourceLineNo">4959</span>
this.decrMemStoreSize(snapshotSize);<a name="line.4959"></a>
<span class="sourceLineNo">4960</span>
this.prepareFlushResult.storeFlushCtxs.remove(family);<a name="line.4960"></a>
<span class="sourceLineNo">4961</span> }<a name="line.4961"></a>
<span class="sourceLineNo">4962</span> }<a name="line.4962"></a>
<span class="sourceLineNo">4963</span> }<a name="line.4963"></a>
<span class="sourceLineNo">4964</span><a name="line.4964"></a>
<span class="sourceLineNo">4965</span> // Drop the memstore contents
if they are now smaller than the latest seen flushed file<a
name="line.4965"></a>
-<span class="sourceLineNo">4966</span>
dropMemstoreContentsForSeqId(regionEvent.getLogSequenceNumber(), store);<a
name="line.4966"></a>
+<span class="sourceLineNo">4966</span>
dropMemStoreContentsForSeqId(regionEvent.getLogSequenceNumber(), store);<a
name="line.4966"></a>
<span class="sourceLineNo">4967</span> if (storeSeqId >
this.maxFlushedSeqId) {<a name="line.4967"></a>
<span class="sourceLineNo">4968</span> this.maxFlushedSeqId =
storeSeqId;<a name="line.4968"></a>
<span class="sourceLineNo">4969</span> }<a name="line.4969"></a>
@@ -5156,9 +5156,9 @@
<span class="sourceLineNo">5148</span> null :
this.prepareFlushResult.storeFlushCtxs.get(<a name="line.5148"></a>
<span class="sourceLineNo">5149</span>
store.getColumnFamilyDescriptor().getName());<a name="line.5149"></a>
<span class="sourceLineNo">5150</span> if (ctx != null) {<a
name="line.5150"></a>
-<span class="sourceLineNo">5151</span> MemstoreSize
snapshotSize = store.getFlushableSize();<a name="line.5151"></a>
+<span class="sourceLineNo">5151</span> MemStoreSize
snapshotSize = store.getFlushableSize();<a name="line.5151"></a>
<span class="sourceLineNo">5152</span> ctx.abort();<a
name="line.5152"></a>
-<span class="sourceLineNo">5153</span>
this.decrMemstoreSize(snapshotSize);<a name="line.5153"></a>
+<span class="sourceLineNo">5153</span>
this.decrMemStoreSize(snapshotSize);<a name="line.5153"></a>
<span class="sourceLineNo">5154</span>
this.prepareFlushResult.storeFlushCtxs.remove(<a name="line.5154"></a>
<span class="sourceLineNo">5155</span>
store.getColumnFamilyDescriptor().getName());<a name="line.5155"></a>
<span class="sourceLineNo">5156</span> totalFreedDataSize +=
snapshotSize.getDataSize();<a name="line.5156"></a>
@@ -5177,7 +5177,7 @@
<span class="sourceLineNo">5169</span> // advance the mvcc read point
so that the new flushed files are visible.<a name="line.5169"></a>
<span class="sourceLineNo">5170</span> // either greater than flush seq
number or they were already picked up via flush.<a name="line.5170"></a>
<span class="sourceLineNo">5171</span> for (HStore s : stores.values())
{<a name="line.5171"></a>
-<span class="sourceLineNo">5172</span>
mvcc.advanceTo(s.getMaxMemstoreTS().orElse(0L));<a name="line.5172"></a>
+<span class="sourceLineNo">5172</span>
mvcc.advanceTo(s.getMaxMemStoreTS().orElse(0L));<a name="line.5172"></a>
<span class="sourceLineNo">5173</span> }<a name="line.5173"></a>
<span class="sourceLineNo">5174</span><a name="line.5174"></a>
<span class="sourceLineNo">5175</span><a name="line.5175"></a>
@@ -5192,7 +5192,7 @@
<span class="sourceLineNo">5184</span> if (!map.isEmpty()) {<a
name="line.5184"></a>
<span class="sourceLineNo">5185</span> for (Map.Entry<HStore,
Long> entry : map.entrySet()) {<a name="line.5185"></a>
<span class="sourceLineNo">5186</span> // Drop the memstore contents
if they are now smaller than the latest seen flushed file<a
name="line.5186"></a>
-<span class="sourceLineNo">5187</span> totalFreedDataSize +=
dropMemstoreContentsForSeqId(entry.getValue(), entry.getKey())<a
name="line.5187"></a>
+<span class="sourceLineNo">5187</span> totalFreedDataSize +=
dropMemStoreContentsForSeqId(entry.getValue(), entry.getKey())<a
name="line.5187"></a>
<span class="sourceLineNo">5188</span> .getDataSize();<a
name="line.5188"></a>
<span class="sourceLineNo">5189</span> }<a name="line.5189"></a>
<span class="sourceLineNo">5190</span> }<a name="line.5190"></a>
@@ -5243,7 +5243,7 @@
<span class="sourceLineNo">5235</span> * @param memstoreSize<a
name="line.5235"></a>
<span class="sourceLineNo">5236</span> */<a name="line.5236"></a>
<span class="sourceLineNo">5237</span> @VisibleForTesting<a
name="line.5237"></a>
-<span class="sourceLineNo">5238</span> protected void restoreEdit(HStore s,
Cell cell, MemstoreSize memstoreSize) {<a name="line.5238"></a>
+<span class="sourceLineNo">5238</span> protected void restoreEdit(HStore s,
Cell cell, MemStoreSize memstoreSize) {<a name="line.5238"></a>
<span class="sourceLineNo">5239</span> s.add(cell, memstoreSize);<a
name="line.5239"></a>
<span class="sourceLineNo">5240</span> }<a name="line.5240"></a>
<span class="sourceLineNo">5241</span><a name="line.5241"></a>
@@ -6966,7 +6966,7 @@
<span class="sourceLineNo">6958</span> return null;<a
name="line.6958"></a>
<span class="sourceLineNo">6959</span> }<a name="line.6959"></a>
<span class="sourceLineNo">6960</span> ClientProtos.RegionLoadStats.Builder
stats = ClientProtos.RegionLoadStats.newBuilder();<a name="line.6960"></a>
-<span class="sourceLineNo">6961</span> stats.setMemstoreLoad((int)
(Math.min(100, (this.memstoreDataSize.get() * 100) / this<a
name="line.6961"></a>
+<span class="sourceLineNo">6961</span> stats.setMemStoreLoad((int)
(Math.min(100, (this.memstoreDataSize.get() * 100) / this<a
name="line.6961"></a>
<span class="sourceLineNo">6962</span> .memstoreFlushSize)));<a
name="line.6962"></a>
<span class="sourceLineNo">6963</span> if
(rsServices.getHeapMemoryManager() != null) {<a name="line.6963"></a>
<span class="sourceLineNo">6964</span> // the HeapMemoryManager uses -0.0
to signal a problem asking the JVM,<a name="line.6964"></a>
@@ -7029,7 +7029,7 @@
<span class="sourceLineNo">7021</span> // This is assigned by mvcc either
explicity in the below or in the guts of the WAL append<a name="line.7021"></a>
<span class="sourceLineNo">7022</span> // when it assigns the edit a
sequencedid (A.K.A the mvcc write number).<a name="line.7022"></a>
<span class="sourceLineNo">7023</span> WriteEntry writeEntry = null;<a
name="line.7023"></a>
-<span class="sourceLineNo">7024</span> MemstoreSize memstoreSize = new
MemstoreSize();<a name="line.7024"></a>
+<span class="sourceLineNo">7024</span> MemStoreSize memstoreSize = new
MemStoreSize();<a name="line.7024"></a>
<span class="sourceLineNo">7025</span> try {<a name="line.7025"></a>
<span class="sourceLineNo">7026</span> boolean success = false;<a
name="line.7026"></a>
<span class="sourceLineNo">7027</span> try {<a name="line.7027"></a>
@@ -7063,7 +7063,7 @@
<span class="sourceLineNo">7055</span> long sequenceId =
writeEntry.getWriteNumber();<a name="line.7055"></a>
<span class="sourceLineNo">7056</span> for (Mutation m : mutations)
{<a name="line.7056"></a>
<span class="sourceLineNo">7057</span> // Handle any tag based cell
features.<a name="line.7057"></a>
-<span class="sourceLineNo">7058</span> // TODO: Do we need to call
rewriteCellTags down in applyToMemstore()? Why not before<a
name="line.7058"></a>
+<span class="sourceLineNo">7058</span> // TODO: Do we need to call
rewriteCellTags down in applyToMemStore()? Why not before<a
name="line.7058"></a>
<span class="sourceLineNo">7059</span> // so tags go into WAL?<a
name="line.7059"></a>
<span class="sourceLineNo">7060</span>
rewriteCellTags(m.getFamilyCellMap(), m);<a name="line.7060"></a>
<span class="sourceLineNo">7061</span> for (CellScanner cellScanner
= m.cellScanner(); cellScanner.advance();) {<a name="line.7061"></a>
@@ -7073,7 +7073,7 @@
<span class="sourceLineNo">7065</span> // If no WAL, need to
stamp it here.<a name="line.7065"></a>
<span class="sourceLineNo">7066</span>
CellUtil.setSequenceId(cell, sequenceId);<a name="line.7066"></a>
<span class="sourceLineNo">7067</span> }<a name="line.7067"></a>
-<span class="sourceLineNo">7068</span>
applyToMemstore(getStore(cell), cell, memstoreSize);<a name="line.7068"></a>
+<span class="sourceLineNo">7068</span>
applyToMemStore(getStore(cell), cell, memstoreSize);<a name="line.7068"></a>
<span class="sourceLineNo">7069</span> }<a name="line.7069"></a>
<span class="sourceLineNo">7070</span> }<a name="line.7070"></a>
<span class="sourceLineNo">7071</span><a name="line.7071"></a>
@@ -7109,7 +7109,7 @@
<span class="sourceLineNo">7101</span> } finally {<a name="line.7101"></a>
<span class="sourceLineNo">7102</span> closeRegionOperation();<a
name="line.7102"></a>
<span class="sourceLineNo">7103</span> if (!mutations.isEmpty()) {<a
name="line.7103"></a>
-<span class="sourceLineNo">7104</span> long newSize =
this.addAndGetMemstoreSize(memstoreSize);<a name="line.7104"></a>
+<span class="sourceLineNo">7104</span> long newSize =
this.addAndGetMemStoreSize(memstoreSize);<a name="line.7104"></a>
<span class="sourceLineNo">7105</span> requestFlushIfNeeded(newSize);<a
name="line.7105"></a>
<span class="sourceLineNo">7106</span> }<a name="line.7106"></a>
<span class="sourceLineNo">7107</span> }<a name="line.7107"></a>
@@ -7214,7 +7214,7 @@
<span class="sourceLineNo">7206</span> startRegionOperation(op);<a
name="line.7206"></a>
<span class="sourceLineNo">7207</span> List<Cell> results =
returnResults? new ArrayList<>(mutation.size()): null;<a
name="line.7207"></a>
<span class="sourceLineNo">7208</span> RowLock rowLock = null;<a
name="line.7208"></a>
-<span class="sourceLineNo">7209</span> MemstoreSize memstoreSize = new
MemstoreSize();<a name="line.7209"></a>
+<span class="sourceLineNo">7209</span> MemStoreSize memstoreSize = new
MemStoreSize();<a name="line.7209"></a>
<span class="sourceLineNo">7210</span> try {<a name="line.7210"></a>
<span class="sourceLineNo">7211</span> rowLock =
getRowLockInternal(mutation.getRow(), false);<a name="line.7211"></a>
<span class="sourceLineNo">7212</span>
lock(this.updatesLock.readLock());<a name="line.7212"></a>
@@ -7240,7 +7240,7 @@
<span class="sourceLineNo">7232</span> }<a name="line.7232"></a>
<span class="sourceLineNo">7233</span> // Now write to MemStore. Do it
a column family at a time.<a name="line.7233"></a>
<span class="sourceLineNo">7234</span> for (Map.Entry<HStore,
List<Cell>> e : forMemStore.entrySet()) {<a name="line.7234"></a>
-<span class="sourceLineNo">7235</span> applyToMemstore(e.getKey(),
e.getValue(), true, memstoreSize);<a name="line.7235"></a>
+<span class="sourceLineNo">7235</span> applyToMemStore(e.getKey(),
e.getValue(), true, memstoreSize);<a name="line.7235"></a>
<span class="sourceLineNo">7236</span> }<a name="line.7236"></a>
<span class="sourceLineNo">7237</span>
mvcc.completeAndWait(writeEntry);<a name="line.7237"></a>
<span class="sourceLineNo">7238</span> if (rsServices != null
&& rsServices.getNonceManager() != null) {<a name="line.7238"></a>
@@ -7263,7 +7263,7 @@
<span class="sourceLineNo">7255</span> rowLock.release();<a
name="line.7255"></a>
<span class="sourceLineNo">7256</span> }<a name="line.7256"></a>
<span class="sourceLineNo">7257</span> // Request a cache flush if over
the limit. Do it outside update lock.<a name="line.7257"></a>
-<span class="sourceLineNo">7258</span> if
(isFlushSize(addAndGetMemstoreSize(memstoreSize))) {<a name="line.7258"></a>
+<span class="sourceLineNo">7258</span> if
(isFlushSize(addAndGetMemStoreSize(memstoreSize))) {<a name="line.7258"></a>
<span class="sourceLineNo">7259</span> requestFlush();<a
name="line.7259"></a>
<span class="sourceLineNo">7260</span> }<a name="line.7260"></a>
<span class="sourceLineNo">7261</span> closeRegionOperation(op);<a
name="line.7261"></a>
@@ -7990,7 +7990,7 @@
<span class="sourceLineNo">7982</span><a name="line.7982"></a>
<span class="sourceLineNo">7983</span> @Override<a name="line.7983"></a>
<span class="sourceLineNo">7984</span> public long
getOldestSeqIdOfStore(byte[] familyName) {<a name="line.7984"></a>
-<span class="sourceLineNo">7985</span> return
wal.getEarliestMemstoreSeqNum(getRegionInfo().getEncodedNameAsBytes(),
familyName);<a name="line.7985"></a>
+<span class="sourceLineNo">7985</span> return
wal.getEarliestMemStoreSeqNum(getRegionInfo().getEncodedNameAsBytes(),
familyName);<a name="line.7985"></a>
<span class="sourceLineNo">7986</span> }<a name="line.7986"></a>
<span class="sourceLineNo">7987</span><a name="line.7987"></a>
<span class="sourceLineNo">7988</span> @Override<a name="line.7988"></a>
@@ -8067,7 +8067,7 @@
<span class="sourceLineNo">8059</span> : CellComparator.COMPARATOR;<a
name="line.8059"></a>
<span class="sourceLineNo">8060</span> }<a name="line.8060"></a>
<span class="sourceLineNo">8061</span><a name="line.8061"></a>
-<span class="sourceLineNo">8062</span> public long getMemstoreFlushSize() {<a
name="line.8062"></a>
+<span class="sourceLineNo">8062</span> public long getMemStoreFlushSize() {<a
name="line.8062"></a>
<span class="sourceLineNo">8063</span> return this.memstoreFlushSize;<a
name="line.8063"></a>
<span class="sourceLineNo">8064</span> }<a name="line.8064"></a>
<span class="sourceLineNo">8065</span><a name="line.8065"></a>
@@ -8087,7 +8087,7 @@
<span class="sourceLineNo">8079</span> }<a name="line.8079"></a>
<span class="sourceLineNo">8080</span> buf.append("end-of-stores");<a
name="line.8080"></a>
<span class="sourceLineNo">8081</span> buf.append(", memstore size ");<a
name="line.8081"></a>
-<span class="sourceLineNo">8082</span> buf.append(getMemstoreSize());<a
name="line.8082"></a>
+<span class="sourceLineNo">8082</span> buf.append(getMemStoreSize());<a
name="line.8082"></a>
<span class="sourceLineNo">8083</span> if
(getRegionInfo().getRegionNameAsString().startsWith(regionName)) {<a
name="line.8083"></a>
<span class="sourceLineNo">8084</span> throw new
RuntimeException(buf.toString());<a name="line.8084"></a>
<span class="sourceLineNo">8085</span> }<a name="line.8085"></a>
