hbase-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From git-site-r...@apache.org
Subject [22/51] [partial] hbase-site git commit: Published site at .
Date Mon, 02 Oct 2017 15:13:51 GMT
http://git-wip-us.apache.org/repos/asf/hbase-site/blob/3332caca/devapidocs/src-html/org/apache/hadoop/hbase/regionserver/HRegion.PrepareFlushResult.html
----------------------------------------------------------------------
diff --git a/devapidocs/src-html/org/apache/hadoop/hbase/regionserver/HRegion.PrepareFlushResult.html b/devapidocs/src-html/org/apache/hadoop/hbase/regionserver/HRegion.PrepareFlushResult.html
index a0961f7..4a7f4ae 100644
--- a/devapidocs/src-html/org/apache/hadoop/hbase/regionserver/HRegion.PrepareFlushResult.html
+++ b/devapidocs/src-html/org/apache/hadoop/hbase/regionserver/HRegion.PrepareFlushResult.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&lt;byte[], StoreFlushContext&gt; storeFlushCtxs;<a name="line.519"></a>
 <span class="sourceLineNo">520</span>    final TreeMap&lt;byte[], List&lt;Path&gt;&gt; committedFiles;<a name="line.520"></a>
-<span class="sourceLineNo">521</span>    final TreeMap&lt;byte[], MemstoreSize&gt; storeFlushableSize;<a name="line.521"></a>
+<span class="sourceLineNo">521</span>    final TreeMap&lt;byte[], MemStoreSize&gt; 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&lt;byte[], StoreFlushContext&gt; storeFlushCtxs,<a name="line.534"></a>
 <span class="sourceLineNo">535</span>      TreeMap&lt;byte[], List&lt;Path&gt;&gt; committedFiles,<a name="line.535"></a>
-<span class="sourceLineNo">536</span>      TreeMap&lt;byte[], MemstoreSize&gt; 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&lt;byte[], MemStoreSize&gt; 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&lt;byte[], StoreFlushContext&gt; storeFlushCtxs,<a name="line.544"></a>
 <span class="sourceLineNo">545</span>      TreeMap&lt;byte[], List&lt;Path&gt;&gt; committedFiles,<a name="line.545"></a>
-<span class="sourceLineNo">546</span>      TreeMap&lt;byte[], MemstoreSize&gt; 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&lt;byte[], MemStoreSize&gt; 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&lt;HStore&gt; 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 &gt; 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 &gt; 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 &lt; 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 -&gt; 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 &gt; 0 &amp;&amp; earliest + flushPerChanges &lt; 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&lt;byte[], Long&gt; flushedFamilyNamesToSeq = new HashMap&lt;&gt;();<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&lt;byte[], StoreFlushContext&gt; storeFlushCtxs = new TreeMap&lt;&gt;(Bytes.BYTES_COMPARATOR);<a name="line.2450"></a>
 <span class="sourceLineNo">2451</span>    TreeMap&lt;byte[], List&lt;Path&gt;&gt; committedFiles = new TreeMap&lt;&gt;(Bytes.BYTES_COMPARATOR);<a name="line.2451"></a>
-<span class="sourceLineNo">2452</span>    TreeMap&lt;byte[], MemstoreSize&gt; storeFlushableSize = new TreeMap&lt;&gt;(Bytes.BYTES_COMPARATOR);<a name="line.2452"></a>
+<span class="sourceLineNo">2452</span>    TreeMap&lt;byte[], MemStoreSize&gt; storeFlushableSize = new TreeMap&lt;&gt;(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&lt;RowLock&gt; 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 &amp;&amp; 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&lt;byte[], List&lt;Cell&gt;&gt; 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&lt;byte[], List&lt;Cell&gt;&gt; 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&lt;byte[], List&lt;Cell&gt;&gt; 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&lt;Cell&gt; 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&lt;Cell&gt; 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&lt;Cell&gt; 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 &amp;&amp; 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 &gt; this.getMemstoreFlushSize()) {<a name="line.4043"></a>
+<span class="sourceLineNo">4043</span>    if(memstoreTotalSize &gt; 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 &gt; 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&lt;HStore, Long&gt; 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&lt;Cell&gt; results = returnResults? new ArrayList&lt;&gt;(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&lt;HStore, List&lt;Cell&gt;&gt; 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 &amp;&amp; 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>


Mime
View raw message