This is an automated email from the ASF dual-hosted git repository.
mmerli pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/bookkeeper.git
The following commit(s) were added to refs/heads/master by this push:
new 1f8de8ffa2 Improved efficiency in DigestManager.verify() (#3810)
1f8de8ffa2 is described below
commit 1f8de8ffa2e63bb748b096c1427f58e6b07e5c5c
Author: Matteo Merli <[email protected]>
AuthorDate: Sun Feb 26 20:44:34 2023 -0800
Improved efficiency in DigestManager.verify() (#3810)
---
.../proto/checksum/CRC32CDigestManager.java | 4 +-
.../proto/checksum/CRC32DigestManager.java | 6 +-
.../bookkeeper/proto/checksum/DigestManager.java | 63 +++++++------
.../proto/checksum/DirectMemoryCRC32Digest.java | 5 +-
.../proto/checksum/DummyDigestManager.java | 2 +-
.../proto/checksum/MacDigestManager.java | 4 +-
.../proto/checksum/StandardCRC32Digest.java | 4 +-
.../circe/checksum/Crc32cIntChecksum.java | 4 +-
.../com/scurrilous/circe/checksum/IntHash.java | 5 +
.../scurrilous/circe/checksum/Java8IntHash.java | 16 +++-
.../scurrilous/circe/checksum/Java9IntHash.java | 20 +++-
.../com/scurrilous/circe/checksum/JniIntHash.java | 20 ++--
.../scurrilous/circe/checksum/ChecksumTest.java | 10 +-
.../proto/checksum/DigestManagerBenchmark.java | 102 +++++++++++++++++++++
.../proto/checksum/DigestTypeBenchmark.java | 2 +-
15 files changed, 204 insertions(+), 63 deletions(-)
diff --git
a/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/CRC32CDigestManager.java
b/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/CRC32CDigestManager.java
index c3be132c39..446e0b35ab 100644
---
a/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/CRC32CDigestManager.java
+++
b/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/CRC32CDigestManager.java
@@ -52,9 +52,9 @@ class CRC32CDigestManager extends DigestManager {
}
@Override
- void update(ByteBuf data) {
+ void update(ByteBuf data, int offset, int len) {
MutableInt current = currentCrc.get();
final int lastCrc = current.intValue();
- current.setValue(Crc32cIntChecksum.resumeChecksum(lastCrc, data));
+ current.setValue(Crc32cIntChecksum.resumeChecksum(lastCrc, data,
offset, len));
}
}
diff --git
a/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/CRC32DigestManager.java
b/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/CRC32DigestManager.java
index d06bc8030c..ea34f13069 100644
---
a/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/CRC32DigestManager.java
+++
b/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/CRC32DigestManager.java
@@ -33,7 +33,7 @@ class CRC32DigestManager extends DigestManager {
interface CRC32Digest {
long getValueAndReset();
- void update(ByteBuf buf);
+ void update(ByteBuf buf, int offset, int len);
}
private static final FastThreadLocal<CRC32Digest> crc = new
FastThreadLocal<CRC32Digest>() {
@@ -62,7 +62,7 @@ class CRC32DigestManager extends DigestManager {
}
@Override
- void update(ByteBuf data) {
- crc.get().update(data);
+ void update(ByteBuf data, int offset, int len) {
+ crc.get().update(data, offset, len);
}
}
diff --git
a/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/DigestManager.java
b/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/DigestManager.java
index 7b0f57a945..b142448aa4 100644
---
a/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/DigestManager.java
+++
b/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/DigestManager.java
@@ -19,9 +19,12 @@ package org.apache.bookkeeper.proto.checksum;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.ByteBufUtil;
import io.netty.buffer.CompositeByteBuf;
+import io.netty.buffer.PooledByteBufAllocator;
import io.netty.buffer.Unpooled;
import io.netty.util.ReferenceCountUtil;
+import io.netty.util.concurrent.FastThreadLocal;
import java.security.GeneralSecurityException;
import java.security.NoSuchAlgorithmException;
import org.apache.bookkeeper.client.BKException.BKDigestMatchException;
@@ -51,10 +54,10 @@ public abstract class DigestManager {
abstract int getMacCodeLength();
void update(byte[] data) {
- update(Unpooled.wrappedBuffer(data, 0, data.length));
+ update(Unpooled.wrappedBuffer(data), 0, data.length);
}
- abstract void update(ByteBuf buffer);
+ abstract void update(ByteBuf buffer, int offset, int len);
abstract void populateValueAndReset(ByteBuf buffer);
@@ -109,7 +112,7 @@ public abstract class DigestManager {
headersBuffer.writeLong(lastAddConfirmed);
headersBuffer.writeLong(length);
- update(headersBuffer);
+ update(headersBuffer, 0, METADATA_LENGTH);
// don't unwrap slices
final ByteBuf unwrapped = data.unwrap() != null && data.unwrap()
instanceof CompositeByteBuf
@@ -118,9 +121,9 @@ public abstract class DigestManager {
ReferenceCountUtil.safeRelease(data);
if (unwrapped instanceof CompositeByteBuf) {
- ((CompositeByteBuf) unwrapped).forEach(this::update);
+ ((CompositeByteBuf) unwrapped).forEach(b -> update(b,
b.readerIndex(), b.readableBytes()));
} else {
- update(unwrapped);
+ update(unwrapped, unwrapped.readerIndex(),
unwrapped.readableBytes());
}
populateValueAndReset(headersBuffer);
@@ -144,7 +147,7 @@ public abstract class DigestManager {
headersBuffer.writeLong(ledgerId);
headersBuffer.writeLong(lac);
- update(headersBuffer);
+ update(headersBuffer, 0, LAC_METADATA_LENGTH);
populateValueAndReset(headersBuffer);
return ByteBufList.get(headersBuffer);
@@ -158,6 +161,18 @@ public abstract class DigestManager {
verifyDigest(entryId, dataReceived, false);
}
+ private static final FastThreadLocal<ByteBuf> DIGEST_BUFFER = new
FastThreadLocal<ByteBuf>() {
+ @Override
+ protected ByteBuf initialValue() throws Exception {
+ return PooledByteBufAllocator.DEFAULT.directBuffer(1024);
+ }
+
+ @Override
+ protected void onRemoval(ByteBuf value) throws Exception {
+ value.release();
+ }
+ };
+
private void verifyDigest(long entryId, ByteBuf dataReceived, boolean
skipEntryIdCheck)
throws BKDigestMatchException {
@@ -168,21 +183,18 @@ public abstract class DigestManager {
this.getClass().getName(), dataReceived.readableBytes());
throw new BKDigestMatchException();
}
- update(dataReceived.slice(0, METADATA_LENGTH));
+ update(dataReceived, 0, METADATA_LENGTH);
int offset = METADATA_LENGTH + macCodeLength;
- update(dataReceived.slice(offset, dataReceived.readableBytes() -
offset));
+ update(dataReceived, offset, dataReceived.readableBytes() - offset);
- ByteBuf digest = allocator.buffer(macCodeLength);
+ ByteBuf digest = DIGEST_BUFFER.get();
+ digest.clear();
populateValueAndReset(digest);
- try {
- if (digest.compareTo(dataReceived.slice(METADATA_LENGTH,
macCodeLength)) != 0) {
- logger.error("Mac mismatch for ledger-id: " + ledgerId + ",
entry-id: " + entryId);
- throw new BKDigestMatchException();
- }
- } finally {
- ReferenceCountUtil.safeRelease(digest);
+ if (!ByteBufUtil.equals(digest, 0, dataReceived, METADATA_LENGTH,
macCodeLength)) {
+ logger.error("Mac mismatch for ledger-id: " + ledgerId + ",
entry-id: " + entryId);
+ throw new BKDigestMatchException();
}
long actualLedgerId = dataReceived.readLong();
@@ -211,20 +223,17 @@ public abstract class DigestManager {
throw new BKDigestMatchException();
}
- update(dataReceived.slice(0, LAC_METADATA_LENGTH));
+ update(dataReceived, 0, LAC_METADATA_LENGTH);
- ByteBuf digest = allocator.buffer(macCodeLength);
- try {
- populateValueAndReset(digest);
+ ByteBuf digest = DIGEST_BUFFER.get();
+ digest.clear();
- if (digest.compareTo(dataReceived.slice(LAC_METADATA_LENGTH,
macCodeLength)) != 0) {
- logger.error("Mac mismatch for ledger-id LAC: " + ledgerId);
- throw new BKDigestMatchException();
- }
- } finally {
- ReferenceCountUtil.safeRelease(digest);
- }
+ populateValueAndReset(digest);
+ if (!ByteBufUtil.equals(digest, 0, dataReceived, LAC_METADATA_LENGTH,
macCodeLength)) {
+ logger.error("Mac mismatch for ledger-id LAC: " + ledgerId);
+ throw new BKDigestMatchException();
+ }
long actualLedgerId = dataReceived.readLong();
long lac = dataReceived.readLong();
if (actualLedgerId != ledgerId) {
diff --git
a/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/DirectMemoryCRC32Digest.java
b/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/DirectMemoryCRC32Digest.java
index f2f03452f4..eda223ef7f 100644
---
a/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/DirectMemoryCRC32Digest.java
+++
b/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/DirectMemoryCRC32Digest.java
@@ -43,10 +43,7 @@ class DirectMemoryCRC32Digest implements CRC32Digest {
}
@Override
- public void update(ByteBuf buf) {
- int index = buf.readerIndex();
- int length = buf.readableBytes();
-
+ public void update(ByteBuf buf, int index, int length) {
try {
if (buf.hasMemoryAddress()) {
// Calculate CRC directly from the direct memory pointer
diff --git
a/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/DummyDigestManager.java
b/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/DummyDigestManager.java
index e5a701508b..9414c3ee55 100644
---
a/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/DummyDigestManager.java
+++
b/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/DummyDigestManager.java
@@ -38,7 +38,7 @@ public class DummyDigestManager extends DigestManager {
}
@Override
- void update(ByteBuf buffer) {}
+ void update(ByteBuf buffer, int offset, int len) {}
@Override
void populateValueAndReset(ByteBuf buffer) {}
diff --git
a/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/MacDigestManager.java
b/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/MacDigestManager.java
index b1dd44fc38..515e0f2484 100644
---
a/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/MacDigestManager.java
+++
b/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/MacDigestManager.java
@@ -96,8 +96,8 @@ public class MacDigestManager extends DigestManager {
}
@Override
- void update(ByteBuf data) {
- mac.get().update(data.nioBuffer());
+ void update(ByteBuf data, int offset, int len) {
+ mac.get().update(data.slice(offset, len).nioBuffer());
}
diff --git
a/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/StandardCRC32Digest.java
b/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/StandardCRC32Digest.java
index 6d2769c47c..3d48f0ef7d 100644
---
a/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/StandardCRC32Digest.java
+++
b/bookkeeper-server/src/main/java/org/apache/bookkeeper/proto/checksum/StandardCRC32Digest.java
@@ -36,7 +36,7 @@ class StandardCRC32Digest implements CRC32Digest {
}
@Override
- public void update(ByteBuf buf) {
- crc.update(buf.nioBuffer());
+ public void update(ByteBuf buf, int offset, int len) {
+ crc.update(buf.slice(offset, len).nioBuffer());
}
}
diff --git
a/circe-checksum/src/main/java/com/scurrilous/circe/checksum/Crc32cIntChecksum.java
b/circe-checksum/src/main/java/com/scurrilous/circe/checksum/Crc32cIntChecksum.java
index c286b6d51b..40c6080823 100644
---
a/circe-checksum/src/main/java/com/scurrilous/circe/checksum/Crc32cIntChecksum.java
+++
b/circe-checksum/src/main/java/com/scurrilous/circe/checksum/Crc32cIntChecksum.java
@@ -53,8 +53,8 @@ public class Crc32cIntChecksum {
* @param payload
* @return
*/
- public static int resumeChecksum(int previousChecksum, ByteBuf payload) {
- return CRC32C_HASH.resume(previousChecksum, payload);
+ public static int resumeChecksum(int previousChecksum, ByteBuf payload,
int offset, int len) {
+ return CRC32C_HASH.resume(previousChecksum, payload, offset, len);
}
}
diff --git
a/circe-checksum/src/main/java/com/scurrilous/circe/checksum/IntHash.java
b/circe-checksum/src/main/java/com/scurrilous/circe/checksum/IntHash.java
index e0e0939cef..e8922e3a16 100644
--- a/circe-checksum/src/main/java/com/scurrilous/circe/checksum/IntHash.java
+++ b/circe-checksum/src/main/java/com/scurrilous/circe/checksum/IntHash.java
@@ -22,5 +22,10 @@ import io.netty.buffer.ByteBuf;
public interface IntHash {
int calculate(ByteBuf buffer);
+
+ int calculate(ByteBuf buffer, int offset, int len);
+
int resume(int current, ByteBuf buffer);
+
+ int resume(int current, ByteBuf buffer, int offset, int len);
}
diff --git
a/circe-checksum/src/main/java/com/scurrilous/circe/checksum/Java8IntHash.java
b/circe-checksum/src/main/java/com/scurrilous/circe/checksum/Java8IntHash.java
index 756a1db1c2..fd548bc4de 100644
---
a/circe-checksum/src/main/java/com/scurrilous/circe/checksum/Java8IntHash.java
+++
b/circe-checksum/src/main/java/com/scurrilous/circe/checksum/Java8IntHash.java
@@ -36,11 +36,21 @@ public class Java8IntHash implements IntHash {
@Override
public int resume(int current, ByteBuf buffer) {
+ return resume(current, buffer, buffer.readerIndex(),
buffer.readableBytes());
+ }
+
+ @Override
+ public int calculate(ByteBuf buffer, int offset, int len) {
+ return resume(0, buffer, offset, len);
+ }
+
+ @Override
+ public int resume(int current, ByteBuf buffer, int offset, int len) {
if (buffer.hasArray()) {
- return hash.resume(current, buffer.array(), buffer.arrayOffset() +
buffer.readerIndex(),
- buffer.readableBytes());
+ return hash.resume(current, buffer.array(), buffer.arrayOffset() +
offset,
+ len);
} else {
- return hash.resume(current, buffer.nioBuffer());
+ return hash.resume(current, buffer.slice(offset, len).nioBuffer());
}
}
}
diff --git
a/circe-checksum/src/main/java/com/scurrilous/circe/checksum/Java9IntHash.java
b/circe-checksum/src/main/java/com/scurrilous/circe/checksum/Java9IntHash.java
index 402a692993..622c66d9ee 100644
---
a/circe-checksum/src/main/java/com/scurrilous/circe/checksum/Java9IntHash.java
+++
b/circe-checksum/src/main/java/com/scurrilous/circe/checksum/Java9IntHash.java
@@ -71,6 +71,11 @@ public class Java9IntHash implements IntHash {
return resume(0, buffer);
}
+ @Override
+ public int calculate(ByteBuf buffer, int offset, int len) {
+ return resume(0, buffer, offset, len);
+ }
+
private int resume(int current, long address, int offset, int length) {
try {
return (int) UPDATE_DIRECT_BYTEBUFFER.invoke(null, current,
address, offset, offset + length);
@@ -89,19 +94,24 @@ public class Java9IntHash implements IntHash {
@Override
public int resume(int current, ByteBuf buffer) {
+ return resume(current, buffer, buffer.readerIndex(),
buffer.readableBytes());
+ }
+
+ @Override
+ public int resume(int current, ByteBuf buffer, int offset, int len) {
int negCrc = ~current;
if (buffer.hasMemoryAddress()) {
- negCrc = resume(negCrc, buffer.memoryAddress(),
buffer.readerIndex(), buffer.readableBytes());
+ negCrc = resume(negCrc, buffer.memoryAddress(), offset, len);
} else if (buffer.hasArray()) {
- int offset = buffer.arrayOffset() + buffer.readerIndex();
- negCrc = resume(negCrc, buffer.array(), offset,
buffer.readableBytes());
+ int arrayOffset = buffer.arrayOffset() + offset;
+ negCrc = resume(negCrc, buffer.array(), arrayOffset, len);
} else {
byte[] b = TL_BUFFER.get();
- int toRead = buffer.readableBytes();
+ int toRead = len;
while (toRead > 0) {
int length = Math.min(toRead, b.length);
- buffer.readBytes(b, 0, length);
+ buffer.slice(offset, len).readBytes(b, 0, length);
negCrc = resume(negCrc, b, 0, length);
toRead -= length;
}
diff --git
a/circe-checksum/src/main/java/com/scurrilous/circe/checksum/JniIntHash.java
b/circe-checksum/src/main/java/com/scurrilous/circe/checksum/JniIntHash.java
index cc29496396..e8e87bf6b1 100644
--- a/circe-checksum/src/main/java/com/scurrilous/circe/checksum/JniIntHash.java
+++ b/circe-checksum/src/main/java/com/scurrilous/circe/checksum/JniIntHash.java
@@ -28,19 +28,27 @@ public class JniIntHash implements IntHash {
@Override
public int calculate(ByteBuf buffer) {
- return resume(0, buffer);
+ return calculate(buffer, buffer.readerIndex(), buffer.readableBytes());
}
@Override
public int resume(int current, ByteBuf buffer) {
+ return resume(current, buffer, buffer.readerIndex(),
buffer.readableBytes());
+ }
+
+ @Override
+ public int calculate(ByteBuf buffer, int offset, int len) {
+ return resume(0, buffer, offset, len);
+ }
+
+ @Override
+ public int resume(int current, ByteBuf buffer, int offset, int len) {
if (buffer.hasMemoryAddress()) {
- return hash.resume(current, buffer.memoryAddress() +
buffer.readerIndex(),
- buffer.readableBytes());
+ return hash.resume(current, buffer.memoryAddress() + offset, len);
} else if (buffer.hasArray()) {
- return hash.resume(current, buffer.array(), buffer.arrayOffset() +
buffer.readerIndex(),
- buffer.readableBytes());
+ return hash.resume(current, buffer.array(), buffer.arrayOffset() +
offset, len);
} else {
- return hash.resume(current, buffer.nioBuffer());
+ return hash.resume(current, buffer.slice(offset, len).nioBuffer());
}
}
}
diff --git
a/circe-checksum/src/test/java/com/scurrilous/circe/checksum/ChecksumTest.java
b/circe-checksum/src/test/java/com/scurrilous/circe/checksum/ChecksumTest.java
index f085b18925..f68b362a1a 100644
---
a/circe-checksum/src/test/java/com/scurrilous/circe/checksum/ChecksumTest.java
+++
b/circe-checksum/src/test/java/com/scurrilous/circe/checksum/ChecksumTest.java
@@ -44,7 +44,7 @@ public class ChecksumTest {
@Test
public void testCrc32cValueResume() {
final byte[] bytes = "Some String".getBytes();
- int checksum = Crc32cIntChecksum.resumeChecksum(0,
Unpooled.wrappedBuffer(bytes));
+ int checksum = Crc32cIntChecksum.resumeChecksum(0,
Unpooled.wrappedBuffer(bytes), 0, bytes.length);
assertEquals(608512271, checksum);
}
@@ -58,19 +58,19 @@ public class ChecksumTest {
checksum =
Crc32cIntChecksum.computeChecksum(Unpooled.wrappedBuffer(bytes, 0, 1));
for (int i = 1; i < bytes.length; i++) {
- checksum = Crc32cIntChecksum.resumeChecksum(checksum,
Unpooled.wrappedBuffer(bytes, i, 1));
+ checksum = Crc32cIntChecksum.resumeChecksum(checksum,
Unpooled.wrappedBuffer(bytes), i, 1);
}
assertEquals(608512271, checksum);
checksum =
Crc32cIntChecksum.computeChecksum(Unpooled.wrappedBuffer(bytes, 0, 4));
- checksum = Crc32cIntChecksum.resumeChecksum(checksum,
Unpooled.wrappedBuffer(bytes, 4, 7));
+ checksum = Crc32cIntChecksum.resumeChecksum(checksum,
Unpooled.wrappedBuffer(bytes), 4, 7);
assertEquals(608512271, checksum);
ByteBuf buffer = Unpooled.wrappedBuffer(bytes, 0, 4);
checksum = Crc32cIntChecksum.computeChecksum(buffer);
checksum = Crc32cIntChecksum.resumeChecksum(
- checksum, Unpooled.wrappedBuffer(bytes, 4, bytes.length - 4));
+ checksum, Unpooled.wrappedBuffer(bytes), 4, bytes.length - 4);
assertEquals(608512271, checksum);
}
@@ -86,7 +86,7 @@ public class ChecksumTest {
@Test
public void testCrc32cLongValueResume() {
final byte[] bytes = "Some String".getBytes();
- long checksum = Crc32cIntChecksum.resumeChecksum(0,
Unpooled.wrappedBuffer(bytes));
+ long checksum = Crc32cIntChecksum.resumeChecksum(0,
Unpooled.wrappedBuffer(bytes), 0, bytes.length);
assertEquals(608512271L, checksum);
}
diff --git
a/microbenchmarks/src/main/java/org/apache/bookkeeper/proto/checksum/DigestManagerBenchmark.java
b/microbenchmarks/src/main/java/org/apache/bookkeeper/proto/checksum/DigestManagerBenchmark.java
new file mode 100644
index 0000000000..d954562016
--- /dev/null
+++
b/microbenchmarks/src/main/java/org/apache/bookkeeper/proto/checksum/DigestManagerBenchmark.java
@@ -0,0 +1,102 @@
+/*
+ * 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.bookkeeper.proto.checksum;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.PooledByteBufAllocator;
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.TimeUnit;
+import org.apache.bookkeeper.proto.DataFormats.LedgerMetadataFormat.DigestType;
+import org.apache.bookkeeper.util.ByteBufList;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Threads;
+import org.openjdk.jmh.annotations.Warmup;
+
+/**
+ * Microbenchmarks for different digest type
+ * getting started:
+ * 1. http://tutorials.jenkov.com/java-performance/jmh.html
+ * 2.
http://hg.openjdk.java.net/code-tools/jmh/file/tip/jmh-samples/src/main/java/org/openjdk/jmh/samples/
+ * 3. google
+ * To run:
+ * build project from command line.
+ * execute ./run.sh
+ */
+public class DigestManagerBenchmark {
+
+ static byte[] randomBytes(int sz) {
+ byte[] b = new byte[sz];
+ ThreadLocalRandom.current().nextBytes(b);
+ return b;
+ }
+
+ /**
+ * MyState.
+ */
+ @State(Scope.Thread)
+ public static class MyState {
+
+ @Param({"64", "1024", "4086", "8192"})
+ public int entrySize;
+
+ private DigestManager dm;
+
+ public ByteBuf digestBuf;
+
+ @Setup(Level.Trial)
+ public void doSetup() throws Exception {
+ final byte[] password =
"password".getBytes(StandardCharsets.UTF_8);
+
+ dm =
DigestManager.instantiate(ThreadLocalRandom.current().nextLong(0,
Long.MAX_VALUE),
+ password, DigestType.CRC32C,
PooledByteBufAllocator.DEFAULT, true);
+
+ ByteBuf data = ByteBufAllocator.DEFAULT.directBuffer(entrySize,
entrySize);
+ data.writeBytes(randomBytes(entrySize));
+
+ digestBuf = ByteBufAllocator.DEFAULT.directBuffer();
+ digestBuf.writeBytes(ByteBufList.coalesce(
+ dm.computeDigestAndPackageForSending(1234, 1234,
entrySize, data)));
+ }
+ }
+
+ @Benchmark
+ @BenchmarkMode(Mode.Throughput)
+ @OutputTimeUnit(TimeUnit.MICROSECONDS)
+ @Warmup(iterations = 2, time = 3, timeUnit = TimeUnit.SECONDS)
+ @Measurement(iterations = 3, time = 10, timeUnit = TimeUnit.SECONDS)
+ @Threads(2)
+ @Fork(1)
+ public void verifyDigest(MyState state) throws Exception {
+ state.digestBuf.readerIndex(0);
+ state.dm.verifyDigestAndReturnData(1234, state.digestBuf);
+ }
+}
diff --git
a/microbenchmarks/src/main/java/org/apache/bookkeeper/proto/checksum/DigestTypeBenchmark.java
b/microbenchmarks/src/main/java/org/apache/bookkeeper/proto/checksum/DigestTypeBenchmark.java
index b26bf4cdd9..59bb6708bf 100644
---
a/microbenchmarks/src/main/java/org/apache/bookkeeper/proto/checksum/DigestTypeBenchmark.java
+++
b/microbenchmarks/src/main/java/org/apache/bookkeeper/proto/checksum/DigestTypeBenchmark.java
@@ -172,7 +172,7 @@ public class DigestTypeBenchmark {
public void digestManager(MyState state) {
final ByteBuf buff = state.getByteBuff(state.bufferType);
final DigestManager dm = state.getDigestManager(state.digest);
- dm.update(buff);
+ dm.update(buff, 0, buff.readableBytes());
state.digestBuf.clear();
dm.populateValueAndReset(state.digestBuf);
}