diff --git a/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestIncrement.java b/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestIncrement.java
index 4b9f113..c38340d 100644
--- a/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestIncrement.java
+++ b/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestIncrement.java
@@ -30,7 +30,7 @@ import org.junit.experimental.categories.Category;
@Category({ClientTests.class, SmallTests.class})
public class TestIncrement {
@Test
- public void test() {
+ public void testIncrementInstance() {
final long expected = 13;
Increment inc = new Increment(new byte [] {'r'});
int total = 0;
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java
index c93123c..3cf4122 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java
@@ -1275,7 +1275,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi
@Override
public long getReadPoint(IsolationLevel isolationLevel) {
- if (isolationLevel == IsolationLevel.READ_UNCOMMITTED) {
+ if (isolationLevel != null && isolationLevel == IsolationLevel.READ_UNCOMMITTED) {
// This scan can read even uncommitted transactions
return Long.MAX_VALUE;
}
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Region.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Region.java
index c0bc8fe..213b41a 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Region.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Region.java
@@ -156,7 +156,7 @@ public interface Region extends ConfigurationObserver {
/** @return true if loading column families on demand by default */
boolean isLoadingCfsOnDemandDefault();
- /** @return readpoint considering given IsolationLevel */
+ /** @return readpoint considering given IsolationLevel; pass null for default*/
long getReadPoint(IsolationLevel isolationLevel);
/**
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/FSHLog.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/FSHLog.java
index 47e28b3..09da8fc 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/FSHLog.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/FSHLog.java
@@ -1,5 +1,4 @@
/**
-
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
@@ -508,16 +507,16 @@ public class FSHLog implements WAL {
FSUtils.getDefaultBlockSize(this.fs, this.fullPathLogDir));
this.logrollsize =
(long)(blocksize * conf.getFloat("hbase.regionserver.logroll.multiplier", 0.95f));
-
+
float memstoreRatio = conf.getFloat(HeapMemorySizeUtil.MEMSTORE_SIZE_KEY,
- conf.getFloat(HeapMemorySizeUtil.MEMSTORE_SIZE_OLD_KEY,
+ conf.getFloat(HeapMemorySizeUtil.MEMSTORE_SIZE_OLD_KEY,
HeapMemorySizeUtil.DEFAULT_MEMSTORE_SIZE));
boolean maxLogsDefined = conf.get("hbase.regionserver.maxlogs") != null;
if(maxLogsDefined){
LOG.warn("'hbase.regionserver.maxlogs' was deprecated.");
}
- this.maxLogs = conf.getInt("hbase.regionserver.maxlogs",
- Math.max(32, calculateMaxLogFiles(memstoreRatio, logrollsize)));
+ this.maxLogs = conf.getInt("hbase.regionserver.maxlogs",
+ Math.max(32, calculateMaxLogFiles(memstoreRatio, logrollsize)));
this.minTolerableReplication = conf.getInt("hbase.regionserver.hlog.tolerable.lowreplication",
FSUtils.getDefaultReplication(fs, this.fullPathLogDir));
this.lowReplicationRollLimit =
@@ -572,7 +571,7 @@ public class FSHLog implements WAL {
int maxLogs = Math.round(mu.getMax() * memstoreSizeRatio * 2 / logRollSize);
return maxLogs;
}
-
+
/**
* Get the backing files associated with this WAL.
* @return may be null if there are no files.
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/HLogKey.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/HLogKey.java
index 3e548ad..c094ced 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/HLogKey.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/HLogKey.java
@@ -49,7 +49,7 @@ import com.google.common.annotations.VisibleForTesting;
*
*
Some Transactional edits (START, COMMIT, ABORT) will not have an
* associated row.
- * @deprecated use WALKey. as of 2.0. Remove in 3.0
+ * @deprecated use WALKey. Deprecated as of 1.0 (HBASE-12522). Remove in 2.0
*/
@InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.REPLICATION)
@Deprecated
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/ReplayHLogKey.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/ReplayHLogKey.java
index f7ae208..d5a1561 100644
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/ReplayHLogKey.java
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/ReplayHLogKey.java
@@ -18,7 +18,6 @@
package org.apache.hadoop.hbase.regionserver.wal;
-import java.io.IOException;
import java.util.List;
import java.util.UUID;
@@ -49,7 +48,7 @@ public class ReplayHLogKey extends HLogKey {
* @return long the new assigned sequence number
*/
@Override
- public long getSequenceId() throws IOException {
+ public long getSequenceId() {
return this.getOrigLogSeqNum();
}
-}
+}
\ No newline at end of file
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/IncrementPerformanceTest.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/IncrementPerformanceTest.java
new file mode 100644
index 0000000..aed3d0a
--- /dev/null
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/IncrementPerformanceTest.java
@@ -0,0 +1,128 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase;
+
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hbase.client.Connection;
+import org.apache.hadoop.hbase.client.ConnectionFactory;
+import org.apache.hadoop.hbase.client.Table;
+import org.apache.hadoop.hbase.util.Bytes;
+import org.apache.hadoop.util.Tool;
+import org.apache.hadoop.util.ToolRunner;
+
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.Snapshot;
+import com.codahale.metrics.Timer;
+
+
+/**
+ * Simple Increments Performance Test. Run this from main. It is to go against a cluster.
+ * Presumption is the table exists already. Defaults are a zk ensemble of localhost:2181,
+ * a tableName of 'tableName', a column famly name of 'columnFamilyName', with 80 threads by
+ * default and 10000 increments per thread. To change any of these configs, pass -DNAME=VALUE as
+ * in -DtableName="newTableName". It prints out configuration it is running with at the start and
+ * on the end it prints out percentiles.
+ */
+public class IncrementPerformanceTest implements Tool {
+ private static final Log LOG = LogFactory.getLog(IncrementPerformanceTest.class);
+ private static final byte [] QUALIFIER = new byte [] {'q'};
+ private Configuration conf;
+ private final MetricRegistry metrics = new MetricRegistry();
+ private static final String TABLENAME = "tableName";
+ private static final String COLUMN_FAMILY = "columnFamilyName";
+ private static final String THREAD_COUNT = "threadCount";
+ private static final int DEFAULT_THREAD_COUNT = 80;
+ private static final String INCREMENT_COUNT = "incrementCount";
+ private static final int DEFAULT_INCREMENT_COUNT = 10000;
+
+ IncrementPerformanceTest() {}
+
+ public int run(final String [] args) throws Exception {
+ Configuration conf = getConf();
+ final TableName tableName = TableName.valueOf(conf.get(TABLENAME), TABLENAME);
+ final byte [] columnFamilyName = Bytes.toBytes(conf.get(COLUMN_FAMILY, COLUMN_FAMILY));
+ int threadCount = conf.getInt(THREAD_COUNT, DEFAULT_THREAD_COUNT);
+ final int incrementCount = conf.getInt(INCREMENT_COUNT, DEFAULT_INCREMENT_COUNT);
+ LOG.info("Running test with " + HConstants.ZOOKEEPER_QUORUM + "=" +
+ getConf().get(HConstants.ZOOKEEPER_QUORUM) + ", tableName=" + tableName +
+ ", columnFamilyName=" + columnFamilyName + ", threadCount=" + threadCount +
+ ", incrementCount=" + incrementCount);
+
+ ExecutorService service = Executors.newFixedThreadPool(threadCount);
+ Set> futures = new HashSet>();
+ final AtomicInteger integer = new AtomicInteger(0); // needed a simple "final" counter
+ while (integer.incrementAndGet() <= threadCount) {
+ futures.add(service.submit(new Runnable() {
+ @Override
+ public void run() {
+ try {
+ try (Connection connection = ConnectionFactory.createConnection(getConf())) {
+ try (Table table = connection.getTable(tableName)) {
+ Timer timer = metrics.timer("increments");
+ for (int i = 0; i < incrementCount; i++) {
+ byte[] row = Bytes.toBytes(i);
+ Timer.Context context = timer.time();
+ try {
+ table.incrementColumnValue(row, columnFamilyName, QUALIFIER, 1l);
+ } catch (IOException e) {
+ // swallow..it's a test.
+ } finally {
+ context.stop();
+ }
+ }
+ }
+ }
+ } catch (IOException ioe) {
+ throw new RuntimeException(ioe);
+ }
+ }
+ }));
+ }
+
+ for(Future> future : futures) future.get();
+ service.shutdown();
+ Snapshot s = metrics.timer("increments").getSnapshot();
+ LOG.info(String.format("75th=%s, 95th=%s, 99th=%s", s.get75thPercentile(),
+ s.get95thPercentile(), s.get99thPercentile()));
+ return 0;
+ }
+
+ @Override
+ public Configuration getConf() {
+ return this.conf;
+ }
+
+ @Override
+ public void setConf(Configuration conf) {
+ this.conf = conf;
+ }
+
+ public static void main(String[] args) throws Exception {
+ System.exit(ToolRunner.run(HBaseConfiguration.create(), new IncrementPerformanceTest(), args));
+ }
+}
\ No newline at end of file
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide.java
index 8734aea..63d9cd0 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide.java
@@ -48,7 +48,6 @@ import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
-import org.apache.hadoop.hbase.DoNotRetryIOException;
import org.apache.hadoop.hbase.HBaseTestingUtility;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HConstants;
@@ -119,6 +118,7 @@ import org.junit.experimental.categories.Category;
@Category({LargeTests.class, ClientTests.class})
@SuppressWarnings ("deprecation")
public class TestFromClientSide {
+ // NOTE: Increment tests were moved to their own class, TestIncrementsFromClientSide.
private static final Log LOG = LogFactory.getLog(TestFromClientSide.class);
protected final static HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility();
private static byte [] ROW = Bytes.toBytes("testRow");
@@ -3046,7 +3046,7 @@ public class TestFromClientSide {
equals(value, CellUtil.cloneValue(key)));
}
- private void assertIncrementKey(Cell key, byte [] row, byte [] family,
+ static void assertIncrementKey(Cell key, byte [] row, byte [] family,
byte [] qualifier, long value)
throws Exception {
assertTrue("Expected row [" + Bytes.toString(row) + "] " +
@@ -3270,7 +3270,7 @@ public class TestFromClientSide {
return stamps;
}
- private boolean equals(byte [] left, byte [] right) {
+ static boolean equals(byte [] left, byte [] right) {
if (left == null && right == null) return true;
if (left == null && right.length == 0) return true;
if (right == null && left.length == 0) return true;
@@ -4399,264 +4399,6 @@ public class TestFromClientSide {
}
@Test
- public void testIncrementWithDeletes() throws Exception {
- LOG.info("Starting testIncrementWithDeletes");
- final TableName TABLENAME =
- TableName.valueOf("testIncrementWithDeletes");
- Table ht = TEST_UTIL.createTable(TABLENAME, FAMILY);
- final byte[] COLUMN = Bytes.toBytes("column");
-
- ht.incrementColumnValue(ROW, FAMILY, COLUMN, 5);
- TEST_UTIL.flush(TABLENAME);
-
- Delete del = new Delete(ROW);
- ht.delete(del);
-
- ht.incrementColumnValue(ROW, FAMILY, COLUMN, 5);
-
- Get get = new Get(ROW);
- Result r = ht.get(get);
- assertEquals(1, r.size());
- assertEquals(5, Bytes.toLong(r.getValue(FAMILY, COLUMN)));
- }
-
- @Test
- public void testIncrementingInvalidValue() throws Exception {
- LOG.info("Starting testIncrementingInvalidValue");
- final TableName TABLENAME = TableName.valueOf("testIncrementingInvalidValue");
- Table ht = TEST_UTIL.createTable(TABLENAME, FAMILY);
- final byte[] COLUMN = Bytes.toBytes("column");
- Put p = new Put(ROW);
- // write an integer here (not a Long)
- p.addColumn(FAMILY, COLUMN, Bytes.toBytes(5));
- ht.put(p);
- try {
- ht.incrementColumnValue(ROW, FAMILY, COLUMN, 5);
- fail("Should have thrown DoNotRetryIOException");
- } catch (DoNotRetryIOException iox) {
- // success
- }
- Increment inc = new Increment(ROW);
- inc.addColumn(FAMILY, COLUMN, 5);
- try {
- ht.increment(inc);
- fail("Should have thrown DoNotRetryIOException");
- } catch (DoNotRetryIOException iox) {
- // success
- }
- }
-
- @Test
- public void testIncrementInvalidArguments() throws Exception {
- LOG.info("Starting testIncrementInvalidArguments");
- final TableName TABLENAME = TableName.valueOf("testIncrementInvalidArguments");
- Table ht = TEST_UTIL.createTable(TABLENAME, FAMILY);
- final byte[] COLUMN = Bytes.toBytes("column");
- try {
- // try null row
- ht.incrementColumnValue(null, FAMILY, COLUMN, 5);
- fail("Should have thrown IOException");
- } catch (IOException iox) {
- // success
- }
- try {
- // try null family
- ht.incrementColumnValue(ROW, null, COLUMN, 5);
- fail("Should have thrown IOException");
- } catch (IOException iox) {
- // success
- }
- try {
- // try null qualifier
- ht.incrementColumnValue(ROW, FAMILY, null, 5);
- fail("Should have thrown IOException");
- } catch (IOException iox) {
- // success
- }
- // try null row
- try {
- Increment incNoRow = new Increment((byte [])null);
- incNoRow.addColumn(FAMILY, COLUMN, 5);
- fail("Should have thrown IllegalArgumentException");
- } catch (IllegalArgumentException iax) {
- // success
- } catch (NullPointerException npe) {
- // success
- }
- // try null family
- try {
- Increment incNoFamily = new Increment(ROW);
- incNoFamily.addColumn(null, COLUMN, 5);
- fail("Should have thrown IllegalArgumentException");
- } catch (IllegalArgumentException iax) {
- // success
- }
- // try null qualifier
- try {
- Increment incNoQualifier = new Increment(ROW);
- incNoQualifier.addColumn(FAMILY, null, 5);
- fail("Should have thrown IllegalArgumentException");
- } catch (IllegalArgumentException iax) {
- // success
- }
- }
-
- @Test
- public void testIncrementOutOfOrder() throws Exception {
- LOG.info("Starting testIncrementOutOfOrder");
- final TableName TABLENAME = TableName.valueOf("testIncrementOutOfOrder");
- Table ht = TEST_UTIL.createTable(TABLENAME, FAMILY);
-
- byte [][] QUALIFIERS = new byte [][] {
- Bytes.toBytes("B"), Bytes.toBytes("A"), Bytes.toBytes("C")
- };
-
- Increment inc = new Increment(ROW);
- for (int i=0; iThere is similar test up in TestAtomicOperation. It does a test where it has 100 threads
+ * doing increments across two column families all on one row and the increments are connected to
+ * prove atomicity on row.
+ */
+@Category(MediumTests.class)
+public class TestRegionIncrement {
+ private static final Log LOG = LogFactory.getLog(TestRegionIncrement.class);
+ @Rule public TestName name = new TestName();
+ @Rule public final TestRule timeout =
+ CategoryBasedTimeout.builder().withTimeout(this.getClass()).
+ withLookingForStuckThread(true).build();
+ private static HBaseTestingUtility TEST_UTIL;
+ private final static byte [] INCREMENT_BYTES = Bytes.toBytes("increment");
+ private static final int THREAD_COUNT = 10;
+ private static final int INCREMENT_COUNT = 10000;
+
+ @Before
+ public void setUp() throws Exception {
+ TEST_UTIL = HBaseTestingUtility.createLocalHTU();
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ TEST_UTIL.cleanupTestDir();
+ }
+
+ private HRegion getRegion(final Configuration conf, final String tableName) throws IOException {
+ WAL wal = new FSHLog(FileSystem.get(conf), TEST_UTIL.getDataTestDir(),
+ TEST_UTIL.getDataTestDir().toString(), conf);
+ return (HRegion)TEST_UTIL.createLocalHRegion(Bytes.toBytes(tableName),
+ HConstants.EMPTY_BYTE_ARRAY, HConstants.EMPTY_BYTE_ARRAY, tableName, conf,
+ false, Durability.SKIP_WAL, wal, INCREMENT_BYTES);
+ }
+
+ private void closeRegion(final HRegion region) throws IOException {
+ region.close();
+ region.getWAL().close();
+ }
+
+ @Test
+ public void testMVCCCausingMisRead() throws IOException {
+ final HRegion region = getRegion(TEST_UTIL.getConfiguration(), this.name.getMethodName());
+ try {
+ // ADD TEST HERE!!
+ } finally {
+ closeRegion(region);
+ }
+ }
+
+ /**
+ * Increments a single cell a bunch of times.
+ */
+ private static class SingleCellIncrementer extends Thread {
+ private final int count;
+ private final HRegion region;
+ private final Increment increment;
+
+ SingleCellIncrementer(final int i, final int count, final HRegion region,
+ final Increment increment) {
+ super("" + i);
+ setDaemon(true);
+ this.count = count;
+ this.region = region;
+ this.increment = increment;
+ }
+
+ @Override
+ public void run() {
+ for (int i = 0; i < this.count; i++) {
+ try {
+ this.region.increment(this.increment);
+ // LOG.info(getName() + " " + i);
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+ }
+
+ /**
+ * Increments a random row's Cell count times.
+ */
+ private static class CrossRowCellIncrementer extends Thread {
+ private final int count;
+ private final HRegion region;
+ private final Increment [] increments;
+
+ CrossRowCellIncrementer(final int i, final int count, final HRegion region, final int range) {
+ super("" + i);
+ setDaemon(true);
+ this.count = count;
+ this.region = region;
+ this.increments = new Increment[range];
+ for (int ii = 0; ii < range; ii++) {
+ this.increments[ii] = new Increment(Bytes.toBytes(i));
+ this.increments[ii].addColumn(INCREMENT_BYTES, INCREMENT_BYTES, 1);
+ }
+ }
+
+ @Override
+ public void run() {
+ for (int i = 0; i < this.count; i++) {
+ try {
+ int index = ThreadLocalRandom.current().nextInt(0, this.increments.length);
+ this.region.increment(this.increments[index]);
+ // LOG.info(getName() + " " + index);
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+ }
+
+ /**
+ * Have each thread update its own Cell. Avoid contention with another thread.
+ * @throws IOException
+ * @throws InterruptedException
+ */
+ @Test
+ public void testUnContendedSingleCellIncrement()
+ throws IOException, InterruptedException {
+ final HRegion region = getRegion(TEST_UTIL.getConfiguration(),
+ TestIncrementsFromClientSide.filterStringSoTableNameSafe(this.name.getMethodName()));
+ long startTime = System.currentTimeMillis();
+ try {
+ SingleCellIncrementer [] threads = new SingleCellIncrementer[THREAD_COUNT];
+ for (int i = 0; i < threads.length; i++) {
+ byte [] rowBytes = Bytes.toBytes(i);
+ Increment increment = new Increment(rowBytes);
+ increment.addColumn(INCREMENT_BYTES, INCREMENT_BYTES, 1);
+ threads[i] = new SingleCellIncrementer(i, INCREMENT_COUNT, region, increment);
+ }
+ for (int i = 0; i < threads.length; i++) {
+ threads[i].start();
+ }
+ for (int i = 0; i < threads.length; i++) {
+ threads[i].join();
+ }
+ RegionScanner regionScanner = region.getScanner(new Scan());
+ List cells = new ArrayList(THREAD_COUNT);
+ while(regionScanner.next(cells)) continue;
+ assertEquals(THREAD_COUNT, cells.size());
+ long total = 0;
+ for (Cell cell: cells) total +=
+ Bytes.toLong(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
+ assertEquals(INCREMENT_COUNT * THREAD_COUNT, total);
+ } finally {
+ closeRegion(region);
+ LOG.info(this.name.getMethodName() + " " + (System.currentTimeMillis() - startTime) + "ms");
+ }
+ }
+
+ /**
+ * Have each thread update its own Cell. Avoid contention with another thread.
+ * This is
+ * @throws IOException
+ * @throws InterruptedException
+ */
+ @Test
+ public void testContendedAcrossCellsIncrement()
+ throws IOException, InterruptedException {
+ final HRegion region = getRegion(TEST_UTIL.getConfiguration(),
+ TestIncrementsFromClientSide.filterStringSoTableNameSafe(this.name.getMethodName()));
+ long startTime = System.currentTimeMillis();
+ try {
+ CrossRowCellIncrementer [] threads = new CrossRowCellIncrementer[THREAD_COUNT];
+ for (int i = 0; i < threads.length; i++) {
+ threads[i] = new CrossRowCellIncrementer(i, INCREMENT_COUNT, region, THREAD_COUNT);
+ }
+ for (int i = 0; i < threads.length; i++) {
+ threads[i].start();
+ }
+ for (int i = 0; i < threads.length; i++) {
+ threads[i].join();
+ }
+ RegionScanner regionScanner = region.getScanner(new Scan());
+ List cells = new ArrayList| (100);
+ while(regionScanner.next(cells)) continue;
+ assertEquals(THREAD_COUNT, cells.size());
+ long total = 0;
+ for (Cell cell: cells) total +=
+ Bytes.toLong(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
+ assertEquals(INCREMENT_COUNT * THREAD_COUNT, total);
+ } finally {
+ closeRegion(region);
+ LOG.info(this.name.getMethodName() + " " + (System.currentTimeMillis() - startTime) + "ms");
+ }
+ }
+}
\ No newline at end of file
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestTags.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestTags.java
index 0f7f23a..d99643d 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestTags.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestTags.java
@@ -551,7 +551,7 @@ public class TestTags {
public static class TestCoprocessorForTags extends BaseRegionObserver {
- public static boolean checkTagPresence = false;
+ public static volatile boolean checkTagPresence = false;
public static List tags = null;
@Override
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestFSHLog.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestFSHLog.java
index af47465..fd6d535 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestFSHLog.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestFSHLog.java
@@ -408,13 +408,13 @@ public class TestFSHLog {
}
region.flush(true);
// FlushResult.flushSequenceId is not visible here so go get the current sequence id.
- long currentSequenceId = region.getSequenceId();
+ long currentSequenceId = region.getReadPoint(null);
// Now release the appends
goslow.setValue(false);
synchronized (goslow) {
goslow.notifyAll();
}
- assertTrue(currentSequenceId >= region.getSequenceId());
+ assertTrue(currentSequenceId >= region.getReadPoint(null));
} finally {
region.close(true);
wal.close();
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestWALReplay.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestWALReplay.java
index 011c75d..f004aeb 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestWALReplay.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestWALReplay.java
@@ -894,7 +894,7 @@ public class TestWALReplay {
for (HColumnDescriptor hcd : htd.getFamilies()) {
addRegionEdits(rowName, hcd.getName(), 5, this.ee, region, "x");
}
- long lastestSeqNumber = region.getSequenceId();
+ long lastestSeqNumber = region.getReadPoint(null);
// get the current seq no
wal.doCompleteCacheFlush = true;
// allow complete cache flush with the previous seq number got after first
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestReplicationSmallTests.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestReplicationSmallTests.java
index 47d2880..727b9bb 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestReplicationSmallTests.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestReplicationSmallTests.java
@@ -24,7 +24,6 @@ import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
@@ -50,7 +49,6 @@ import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.client.replication.ReplicationAdmin;
import org.apache.hadoop.hbase.mapreduce.replication.VerifyReplication;
import org.apache.hadoop.hbase.protobuf.generated.WALProtos;
-import org.apache.hadoop.hbase.wal.WALKey;
import org.apache.hadoop.hbase.regionserver.wal.WALEdit;
import org.apache.hadoop.hbase.replication.regionserver.Replication;
import org.apache.hadoop.hbase.testclassification.LargeTests;
@@ -58,14 +56,12 @@ import org.apache.hadoop.hbase.testclassification.ReplicationTests;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
import org.apache.hadoop.hbase.util.JVMClusterUtil;
+import org.apache.hadoop.hbase.wal.WALKey;
import org.apache.hadoop.mapreduce.Job;
import org.junit.Before;
import org.junit.Test;
import org.junit.experimental.categories.Category;
-import com.google.protobuf.ByteString;
-import com.sun.tools.javac.code.Attribute.Array;
-
@Category({ReplicationTests.class, LargeTests.class})
public class TestReplicationSmallTests extends TestReplicationBase {
| | | |