INJECTION_POINTS
+ = new ConcurrentHashMap<>();
+
+ /** Put an injection point. */
+ public static void put(String injectionPoint, Code code) {
+ LOG.debug("put: {}, {}", injectionPoint, code);
+ INJECTION_POINTS.put(injectionPoint, code);
+ }
+
+ /** Execute the injected code, if there is any. */
+ public static boolean execute(String injectionPoint, String localId,
+ String remoteId, Object... args) {
+ final Code code = INJECTION_POINTS.get(injectionPoint);
+ if (code == null) {
+ return false;
+ }
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("execute: {}, {}, localId={}, remoteId={}, args={}",
+ injectionPoint, code, localId, remoteId, Arrays.toString(args));
+ }
+ return code.execute(localId, remoteId, args);
+ }
+}
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/Daemon.java b/ratis-common/src/main/java/org/apache/ratis/util/Daemon.java
new file mode 100644
index 0000000000..1ef95ae600
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/Daemon.java
@@ -0,0 +1,35 @@
+/**
+ * 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.ratis.util;
+
+public class Daemon extends Thread {
+ {
+ setDaemon(true);
+ }
+
+ /** Construct a daemon thread. */
+ public Daemon() {
+ super();
+ }
+
+ /** Construct a daemon thread with the given runnable. */
+ public Daemon(Runnable runnable) {
+ super(runnable);
+ this.setName(runnable.toString());
+ }
+}
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/ExitUtils.java b/ratis-common/src/main/java/org/apache/ratis/util/ExitUtils.java
new file mode 100644
index 0000000000..440434424a
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/ExitUtils.java
@@ -0,0 +1,98 @@
+/**
+ * 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.ratis.util;
+
+import org.slf4j.Logger;
+
+/** Facilitates hooking process termination for tests and debugging. */
+public class ExitUtils {
+ public static class ExitException extends RuntimeException {
+ private static final long serialVersionUID = 1L;
+
+ public final int status;
+
+ public ExitException(int status, String message, Throwable throwable) {
+ super(message, throwable);
+ this.status = status;
+ }
+ }
+
+ private static volatile boolean systemExitDisabled = false;
+ private static volatile ExitException firstExitException;
+
+ /**
+ * @return the first {@link ExitException} thrown, or null if none thrown yet.
+ */
+ public static ExitException getFirstExitException() {
+ return firstExitException;
+ }
+
+ /**
+ * Reset the tracking of process termination.
+ * This is useful when some tests expect an exit but the others do not.
+ */
+ public static void resetFirstExitException() {
+ firstExitException = null;
+ }
+
+ /** @return true if {@link #terminate(int, String, Throwable, Logger)} has been invoked. */
+ public static boolean isTerminated() {
+ // Either this member is set or System.exit is actually invoked.
+ return firstExitException != null;
+ }
+
+ /** Disable the use of {@link System#exit(int)} for testing. */
+ public static void disableSystemExit() {
+ systemExitDisabled = true;
+ }
+
+ /**
+ * Terminate the current process. Note that terminate is the *only* method
+ * that should be used to terminate the daemon processes.
+ *
+ * @param status Exit status
+ * @param message message used to create the {@code ExitException}
+ * @throws ExitException if System.exit is disabled for test purposes
+ */
+ public static void terminate(
+ int status, String message, Throwable throwable, Logger log)
+ throws ExitException {
+ if (log != null) {
+ final String s = "Terminating with exit status " + status + ": " + message;
+ if (status == 0) {
+ log.info(s, throwable);
+ } else {
+ log.error(s, throwable);
+ }
+ }
+
+ if (!systemExitDisabled) {
+ System.exit(status);
+ }
+
+ final ExitException ee = new ExitException(status, message, throwable);
+ if (firstExitException == null) {
+ firstExitException = ee;
+ }
+ throw ee;
+ }
+
+ public static void terminate(int status, String message, Logger log) {
+ terminate(status, message, null, log);
+ }
+}
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/FileUtils.java b/ratis-common/src/main/java/org/apache/ratis/util/FileUtils.java
new file mode 100644
index 0000000000..5dc509d526
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/FileUtils.java
@@ -0,0 +1,207 @@
+/**
+ * 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.ratis.util;
+
+import org.apache.ratis.io.nativeio.NativeIO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.file.Files;
+
+public class FileUtils {
+ public static final Logger LOG = LoggerFactory.getLogger(FileUtils.class);
+
+ public static void truncateFile(File f, long target) throws IOException {
+ try (FileOutputStream out = new FileOutputStream(f, true)) {
+ out.getChannel().truncate(target);
+ }
+ }
+
+ public static void deleteFile(File f) throws IOException {
+ try {
+ Files.delete(f.toPath());
+ } catch (IOException e) {
+ LOG.warn("Could not delete " + f);
+ throw e;
+ }
+ }
+
+ /**
+ * Delete a directory and all its contents. If
+ * we return false, the directory may be partially-deleted.
+ * (1) If dir is symlink to a file, the symlink is deleted. The file pointed
+ * to by the symlink is not deleted.
+ * (2) If dir is symlink to a directory, symlink is deleted. The directory
+ * pointed to by symlink is not deleted.
+ * (3) If dir is a normal file, it is deleted.
+ * (4) If dir is a normal directory, then dir and all its contents recursively
+ * are deleted.
+ */
+ public static boolean fullyDelete(final File dir) {
+ if (deleteImpl(dir, false)) {
+ // dir is (a) normal file, (b) symlink to a file, (c) empty directory or
+ // (d) symlink to a directory
+ return true;
+ }
+ // handle nonempty directory deletion
+ return fullyDeleteContents(dir) && deleteImpl(dir, true);
+ }
+
+ private static boolean deleteImpl(final File f, final boolean doLog) {
+ if (f == null) {
+ LOG.warn("null file argument.");
+ return false;
+ }
+ final boolean wasDeleted = f.delete();
+ if (wasDeleted) {
+ return true;
+ }
+ final boolean ex = f.exists();
+ if (doLog && ex) {
+ LOG.warn("Failed to delete file or dir ["
+ + f.getAbsolutePath() + "]: it still exists.");
+ }
+ return !ex;
+ }
+
+ /**
+ * Delete the contents of a directory, not the directory itself. If
+ * we return false, the directory may be partially-deleted.
+ * If dir is a symlink to a directory, all the contents of the actual
+ * directory pointed to by dir will be deleted.
+ */
+ private static boolean fullyDeleteContents(final File dir) {
+ boolean deletionSucceeded = true;
+ final File[] contents = dir.listFiles();
+ if (contents != null) {
+ for (File content : contents) {
+ if (content.isFile()) {
+ if (!deleteImpl(content, true)) {
+ deletionSucceeded = false;
+ }
+ } else {
+ // Either directory or symlink to another directory.
+ // Try deleting the directory as this might be a symlink
+ if (deleteImpl(content, false)) {
+ // this was indeed a symlink or an empty directory
+ continue;
+ }
+ // if not an empty directory or symlink let
+ // fullyDelete handle it.
+ if (!fullyDelete(content)) {
+ deletionSucceeded = false;
+ // continue deletion of other files/dirs under dir
+ }
+ }
+ }
+ }
+ return deletionSucceeded;
+ }
+
+ /**
+ * Interprets the passed string as a URI. In case of error it
+ * assumes the specified string is a file.
+ *
+ * @param s the string to interpret
+ * @return the resulting URI
+ */
+ public static URI stringAsURI(String s) throws IOException {
+ URI u = null;
+ // try to make a URI
+ try {
+ u = new URI(s);
+ } catch (URISyntaxException e){
+ LOG.error("Syntax error in URI " + s
+ + ". Please check hdfs configuration.", e);
+ }
+
+ // if URI is null or scheme is undefined, then assume it's file://
+ if(u == null || u.getScheme() == null){
+ LOG.warn("Path " + s + " should be specified as a URI "
+ + "in configuration files. Please update configuration.");
+ u = fileAsURI(new File(s));
+ }
+ return u;
+ }
+
+ /**
+ * Converts the passed File to a URI. This method trims the trailing slash if
+ * one is appended because the underlying file is in fact a directory that
+ * exists.
+ *
+ * @param f the file to convert
+ * @return the resulting URI
+ */
+ public static URI fileAsURI(File f) throws IOException {
+ URI u = f.getCanonicalFile().toURI();
+
+ // trim the trailing slash, if it's present
+ if (u.getPath().endsWith("/")) {
+ String uriAsString = u.toString();
+ try {
+ u = new URI(uriAsString.substring(0, uriAsString.length() - 1));
+ } catch (URISyntaxException e) {
+ throw new IOException(e);
+ }
+ }
+ return u;
+ }
+
+ /**
+ * A wrapper for {@link File#listFiles()}. This java.io API returns null
+ * when a dir is not a directory or for any I/O error. Instead of having
+ * null check everywhere File#listFiles() is used, we will add utility API
+ * to get around this problem. For the majority of cases where we prefer
+ * an IOException to be thrown.
+ * @param dir directory for which listing should be performed
+ * @return list of files or empty list
+ * @exception IOException for invalid directory or for a bad disk.
+ */
+ public static File[] listFiles(File dir) throws IOException {
+ File[] files = dir.listFiles();
+ if(files == null) {
+ throw new IOException("Invalid directory or I/O error occurred for dir: "
+ + dir.toString());
+ }
+ return files;
+ }
+
+ /**
+ * Platform independent implementation for {@link File#canWrite()}
+ * @param f input file
+ * @return On Unix, same as {@link File#canWrite()}
+ * On Windows, true if process has write access on the path
+ */
+ public static boolean canWrite(File f) {
+ if (RaftUtils.WINDOWS) {
+ try {
+ return NativeIO.Windows.access(f.getCanonicalPath(),
+ NativeIO.Windows.AccessRight.ACCESS_WRITE);
+ } catch (IOException e) {
+ return false;
+ }
+ } else {
+ return f.canWrite();
+ }
+ }
+}
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/LifeCycle.java b/ratis-common/src/main/java/org/apache/ratis/util/LifeCycle.java
new file mode 100644
index 0000000000..b1f3fa5215
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/LifeCycle.java
@@ -0,0 +1,210 @@
+/**
+ * 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.ratis.util;
+
+import com.google.common.base.Preconditions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * The life cycle of a machine.
+ *
+ * -------------------------------------------------
+ * | -------------------------------- |
+ * | | ------------------------ | |
+ * | | | | | |
+ * | | PAUSED <---- PAUSING---- | | |
+ * | | | ^ | | | | |
+ * | | V | | V V V V
+ * NEW --> STARTING --> RUNNING --|--> CLOSING --> [CLOSED]
+ * ^ | | | | ^
+ * | | | V V |
+ * ------- -------> EXCEPTION -----
+ *
+ * Note that there is no transition from PAUSING to CLOSING.
+ */
+public class LifeCycle {
+ public static final Logger LOG = LoggerFactory.getLogger(LifeCycle.class);
+
+ /** The states in the life cycle. */
+ public enum State {
+ /** The machine is newly created and holds zero resource. */
+ NEW,
+ /** The machine is starting and does not yet provide any service. */
+ STARTING,
+ /** The machine is running and providing service. */
+ RUNNING,
+ /** The machine is pausing and stopping providing service. */
+ PAUSING,
+ /** The machine is paused and does not provide any service. */
+ PAUSED,
+ /** The machine catches an internal exception so that it must be closed. */
+ EXCEPTION,
+ /** The machine is closing, stopping providing service and releasing resources. */
+ CLOSING,
+ /** The machine is closed, a final state. */
+ CLOSED;
+
+ private static final Map> PREDECESSORS;
+
+ /** Does this object equal to one of the given states? */
+ public boolean isOneOf(State... states) {
+ for(State e : states) {
+ if (e == this) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ static void put(State key, Map> map, State... values) {
+ map.put(key, Collections.unmodifiableList(Arrays.asList(values)));
+ }
+
+ static {
+ final Map> predecessors = new EnumMap<>(State.class);
+ put(NEW, predecessors, STARTING);
+ put(STARTING, predecessors, NEW, PAUSED);
+ put(RUNNING, predecessors, STARTING);
+ put(PAUSING, predecessors, RUNNING);
+ put(PAUSED, predecessors, PAUSING);
+ put(EXCEPTION, predecessors, STARTING, PAUSING, RUNNING);
+ put(CLOSING, predecessors, STARTING, RUNNING, PAUSING, PAUSED, EXCEPTION);
+ put(CLOSED, predecessors, NEW, CLOSING);
+
+ PREDECESSORS = Collections.unmodifiableMap(predecessors);
+ }
+
+ /** Is the given transition valid? */
+ static boolean isValid(State from, State to) {
+ return PREDECESSORS.get(to).contains(from);
+ }
+
+ /** Validate the given transition. */
+ static void validate(Object name, State from, State to) {
+ LOG.debug("{}: {} -> {}", name, from, to);
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("TRACE", new Throwable());
+ }
+
+ Preconditions.checkState(isValid(from, to),
+ "ILLEGAL TRANSITION: In %s, %s -> %s", name, from, to);
+ }
+ }
+
+ private volatile String name;
+ private final AtomicReference current = new AtomicReference<>(State.NEW);
+
+ public LifeCycle(Object name) {
+ this.name = name.toString();
+ LOG.debug("{}: {}", name, current);
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ /** Transition from the current state to the given state. */
+ public void transition(final State to) {
+ final State from = current.getAndSet(to);
+ State.validate(name, from, to);
+ }
+
+ /**
+ * If the current state is equal to the specified from state,
+ * then transition to the give to state; otherwise, make no change.
+ *
+ * @return true iff the current state is equal to the specified from state.
+ */
+ public boolean compareAndTransition(final State from, final State to) {
+ if (current.compareAndSet(from, to)) {
+ State.validate(name, from, to);
+ return true;
+ }
+ return false;
+ }
+
+ /** @return the current state. */
+ public State getCurrentState() {
+ return current.get();
+ }
+
+ /** Assert if the current state equals to one of the expected states. */
+ public void assertCurrentState(State... expected) {
+ final State c = getCurrentState();
+ if (!c.isOneOf(expected)) {
+ throw new IllegalStateException("STATE MISMATCHED: In " + name
+ + ", current state " + c + " is not one of the expected states "
+ + Arrays.toString(expected));
+ }
+ }
+
+ @Override
+ public String toString() {
+ return name + ":" + getCurrentState();
+ }
+
+ /** Run the given start method and transition the current state accordingly. */
+ public void startAndTransition(
+ CheckedRunnable startImpl, Class... exceptionClasses)
+ throws T {
+ transition(State.STARTING);
+ try {
+ startImpl.run();
+ transition(State.RUNNING);
+ } catch (Throwable t) {
+ transition(RaftUtils.isInstance(t, exceptionClasses)?
+ State.NEW: State.EXCEPTION);
+ throw t;
+ }
+ }
+
+
+ /**
+ * Check the current state and, if applicable, run the given close method.
+ * This method can be called multiple times
+ * while the given close method will only be executed at most once.
+ */
+ public void checkStateAndClose(
+ CheckedRunnable closeImpl) throws T {
+ if (compareAndTransition(State.NEW, State.CLOSED)) {
+ return;
+ }
+
+ for(;;) {
+ final State c = getCurrentState();
+ if (c.isOneOf(State.CLOSING, State.CLOSED)) {
+ return; //already closing or closed.
+ }
+
+ if (compareAndTransition(c, State.CLOSING)) {
+ try {
+ closeImpl.run();
+ } finally {
+ transition(State.CLOSED);
+ }
+ return;
+ }
+
+ // lifecycle state is changed, retry.
+ }
+ }
+}
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/MD5FileUtil.java b/ratis-common/src/main/java/org/apache/ratis/util/MD5FileUtil.java
new file mode 100644
index 0000000000..7218790cc9
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/MD5FileUtil.java
@@ -0,0 +1,177 @@
+/**
+ * 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.ratis.util;
+
+import com.google.common.base.Charsets;
+
+import org.apache.ratis.io.MD5Hash;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.security.DigestInputStream;
+import java.security.MessageDigest;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public abstract class MD5FileUtil {
+ public static final Logger LOG = LoggerFactory.getLogger(MD5FileUtil.class);
+
+ // TODO: we should provide something like Hadoop's checksum fs for the local filesystem
+ // so that individual state machines do not have to deal with checksumming/corruption prevention.
+ // Keep the checksum and data in the same block format instead of individual files.
+
+ public static final String MD5_SUFFIX = ".md5";
+ private static final Pattern LINE_REGEX =
+ Pattern.compile("([0-9a-f]{32}) [ *](.+)");
+
+ /**
+ * Verify that the previously saved md5 for the given file matches
+ * expectedMd5.
+ */
+ public static void verifySavedMD5(File dataFile, MD5Hash expectedMD5)
+ throws IOException {
+ MD5Hash storedHash = readStoredMd5ForFile(dataFile);
+ // Check the hash itself
+ if (!expectedMD5.equals(storedHash)) {
+ throw new IOException(
+ "File " + dataFile + " did not match stored MD5 checksum " +
+ " (stored: " + storedHash + ", computed: " + expectedMD5);
+ }
+ }
+
+ /**
+ * Read the md5 file stored alongside the given data file and match the md5
+ * file content.
+ * @param md5File the file containing data
+ * @return a matcher with two matched groups where group(1) is the md5 string
+ * and group(2) is the data file path.
+ */
+ private static Matcher readStoredMd5(File md5File) throws IOException {
+ BufferedReader reader =
+ new BufferedReader(new InputStreamReader(new FileInputStream(
+ md5File), Charsets.UTF_8));
+ String md5Line;
+ try {
+ md5Line = reader.readLine();
+ if (md5Line == null) { md5Line = ""; }
+ md5Line = md5Line.trim();
+ } catch (IOException ioe) {
+ throw new IOException("Error reading md5 file at " + md5File, ioe);
+ } finally {
+ RaftUtils.cleanup(LOG, reader);
+ }
+
+ Matcher matcher = LINE_REGEX.matcher(md5Line);
+ if (!matcher.matches()) {
+ throw new IOException("Invalid MD5 file " + md5File + ": the content \""
+ + md5Line + "\" does not match the expected pattern.");
+ }
+ return matcher;
+ }
+
+ /**
+ * Read the md5 checksum stored alongside the given data file.
+ * @param dataFile the file containing data
+ * @return the checksum stored in dataFile.md5
+ */
+ public static MD5Hash readStoredMd5ForFile(File dataFile) throws IOException {
+ final File md5File = getDigestFileForFile(dataFile);
+ if (!md5File.exists()) {
+ return null;
+ }
+
+ final Matcher matcher = readStoredMd5(md5File);
+ String storedHash = matcher.group(1);
+ File referencedFile = new File(matcher.group(2));
+
+ // Sanity check: Make sure that the file referenced in the .md5 file at
+ // least has the same name as the file we expect
+ if (!referencedFile.getName().equals(dataFile.getName())) {
+ throw new IOException(
+ "MD5 file at " + md5File + " references file named " +
+ referencedFile.getName() + " but we expected it to reference " +
+ dataFile);
+ }
+ return new MD5Hash(storedHash);
+ }
+
+ /**
+ * Read dataFile and compute its MD5 checksum.
+ */
+ public static MD5Hash computeMd5ForFile(File dataFile) throws IOException {
+ InputStream in = new FileInputStream(dataFile);
+ try {
+ MessageDigest digester = MD5Hash.getDigester();
+ DigestInputStream dis = new DigestInputStream(in, digester);
+ RaftUtils.readFully(dis, 128*1024);
+
+ return new MD5Hash(digester.digest());
+ } finally {
+ RaftUtils.cleanup(LOG, in);
+ }
+ }
+
+ /**
+ * Save the ".md5" file that lists the md5sum of another file.
+ * @param dataFile the original file whose md5 was computed
+ * @param digest the computed digest
+ */
+ public static void saveMD5File(File dataFile, MD5Hash digest)
+ throws IOException {
+ final String digestString = StringUtils.bytes2HexString(digest.getDigest());
+ saveMD5File(dataFile, digestString);
+ }
+
+ private static void saveMD5File(File dataFile, String digestString)
+ throws IOException {
+ File md5File = getDigestFileForFile(dataFile);
+ String md5Line = digestString + " *" + dataFile.getName() + "\n";
+
+ AtomicFileOutputStream afos = new AtomicFileOutputStream(md5File);
+ afos.write(md5Line.getBytes(Charsets.UTF_8));
+ afos.close();
+
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Saved MD5 " + digestString + " to " + md5File);
+ }
+ }
+
+ public static void renameMD5File(File oldDataFile, File newDataFile)
+ throws IOException {
+ final File fromFile = getDigestFileForFile(oldDataFile);
+ if (!fromFile.exists()) {
+ throw new FileNotFoundException(fromFile + " does not exist.");
+ }
+
+ final String digestString = readStoredMd5(fromFile).group(1);
+ saveMD5File(newDataFile, digestString);
+
+ if (!fromFile.delete()) {
+ LOG.warn("deleting " + fromFile.getAbsolutePath() + " FAILED");
+ }
+ }
+
+ /**
+ * @return a reference to the file with .md5 suffix that will
+ * contain the md5 checksum for the given data file.
+ */
+ public static File getDigestFileForFile(File file) {
+ return new File(file.getParentFile(), file.getName() + MD5_SUFFIX);
+ }
+}
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/NativeCodeLoader.java b/ratis-common/src/main/java/org/apache/ratis/util/NativeCodeLoader.java
new file mode 100644
index 0000000000..94d4e07975
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/NativeCodeLoader.java
@@ -0,0 +1,70 @@
+/**
+ * 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.ratis.util;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * A helper to load the native ratis code i.e. libratis.so.
+ * This handles the fallback to either the bundled libratis-Linux-i386-32.so
+ * or the default java implementations where appropriate.
+ */
+public final class NativeCodeLoader {
+
+ private static final Logger LOG = LoggerFactory.getLogger(NativeCodeLoader.class);
+
+ private static boolean nativeCodeLoaded = false;
+
+ static {
+ // Try to load native ratis library and set fallback flag appropriately
+ LOG.debug("Trying to load the custom-built native-ratis library...");
+ try {
+ System.loadLibrary("ratis");
+ LOG.debug("Loaded the native-ratis library");
+ nativeCodeLoaded = true;
+ } catch (Throwable t) {
+ // Ignore failure to load
+ if(LOG.isDebugEnabled()) {
+ LOG.debug("Failed to load native-ratis with error: " + t);
+ LOG.debug("java.library.path=" +
+ System.getProperty("java.library.path"));
+ }
+ }
+
+ if (!nativeCodeLoaded) {
+ LOG.warn("Unable to load native-ratis library for your platform... " +
+ "using builtin-java classes where applicable");
+ }
+ }
+
+ private NativeCodeLoader() {}
+
+ /**
+ * Check if native-ratis code is loaded for this platform.
+ *
+ * @return true if native-ratis is loaded,
+ * else false
+ */
+ public static boolean isNativeCodeLoaded() {
+ return nativeCodeLoaded;
+ }
+
+ public static native String getLibraryName();
+}
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/NativeCrc32.java b/ratis-common/src/main/java/org/apache/ratis/util/NativeCrc32.java
new file mode 100644
index 0000000000..902d0a7785
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/NativeCrc32.java
@@ -0,0 +1,143 @@
+/**
+ * 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.ratis.util;
+
+import com.google.common.annotations.VisibleForTesting;
+
+import java.nio.ByteBuffer;
+
+import org.apache.ratis.protocol.ChecksumException;
+
+/**
+ * Wrapper around JNI support code to do checksum computation
+ * natively.
+ */
+class NativeCrc32 {
+
+ /**
+ * Return true if the JNI-based native CRC extensions are available.
+ */
+ public static boolean isAvailable() {
+ if (System.getProperty("os.arch").toLowerCase().startsWith("sparc")) {
+ return false;
+ } else {
+ return NativeCodeLoader.isNativeCodeLoaded();
+ }
+ }
+
+ /**
+ * Verify the given buffers of data and checksums, and throw an exception
+ * if any checksum is invalid. The buffers given to this function should
+ * have their position initially at the start of the data, and their limit
+ * set at the end of the data. The position, limit, and mark are not
+ * modified.
+ *
+ * @param bytesPerSum the chunk size (eg 512 bytes)
+ * @param checksumType the DataChecksum type constant (NULL is not supported)
+ * @param sums the DirectByteBuffer pointing at the beginning of the
+ * stored checksums
+ * @param data the DirectByteBuffer pointing at the beginning of the
+ * data to check
+ * @param basePos the position in the file where the data buffer starts
+ * @param fileName the name of the file being verified
+ * @throws ChecksumException if there is an invalid checksum
+ */
+ public static void verifyChunkedSums(int bytesPerSum, int checksumType,
+ ByteBuffer sums, ByteBuffer data, String fileName, long basePos)
+ throws ChecksumException {
+ nativeComputeChunkedSums(bytesPerSum, checksumType,
+ sums, sums.position(),
+ data, data.position(), data.remaining(),
+ fileName, basePos, true);
+ }
+
+ public static void verifyChunkedSumsByteArray(int bytesPerSum,
+ int checksumType, byte[] sums, int sumsOffset, byte[] data,
+ int dataOffset, int dataLength, String fileName, long basePos)
+ throws ChecksumException {
+ nativeComputeChunkedSumsByteArray(bytesPerSum, checksumType,
+ sums, sumsOffset,
+ data, dataOffset, dataLength,
+ fileName, basePos, true);
+ }
+
+ public static void calculateChunkedSums(int bytesPerSum, int checksumType,
+ ByteBuffer sums, ByteBuffer data) {
+ nativeComputeChunkedSums(bytesPerSum, checksumType,
+ sums, sums.position(),
+ data, data.position(), data.remaining(),
+ "", 0, false);
+ }
+
+ public static void calculateChunkedSumsByteArray(int bytesPerSum,
+ int checksumType, byte[] sums, int sumsOffset, byte[] data,
+ int dataOffset, int dataLength) {
+ nativeComputeChunkedSumsByteArray(bytesPerSum, checksumType,
+ sums, sumsOffset,
+ data, dataOffset, dataLength,
+ "", 0, false);
+ }
+
+ /**
+ * Verify the given buffers of data and checksums, and throw an exception
+ * if any checksum is invalid. The buffers given to this function should
+ * have their position initially at the start of the data, and their limit
+ * set at the end of the data. The position, limit, and mark are not
+ * modified. This method is retained only for backwards-compatibility with
+ * prior jar versions that need the corresponding JNI function.
+ *
+ * @param bytesPerSum the chunk size (eg 512 bytes)
+ * @param checksumType the DataChecksum type constant
+ * @param sums the DirectByteBuffer pointing at the beginning of the
+ * stored checksums
+ * @param sumsOffset start offset in sums buffer
+ * @param data the DirectByteBuffer pointing at the beginning of the
+ * data to check
+ * @param dataOffset start offset in data buffer
+ * @param dataLength length of data buffer
+ * @param fileName the name of the file being verified
+ * @param basePos the position in the file where the data buffer starts
+ * @throws ChecksumException if there is an invalid checksum
+ * @deprecated use {@link #nativeComputeChunkedSums(int, int, ByteBuffer, int,
+ * ByteBuffer, int, int, String, long, boolean)} instead
+ */
+ @Deprecated
+ @VisibleForTesting
+ static native void nativeVerifyChunkedSums(
+ int bytesPerSum, int checksumType,
+ ByteBuffer sums, int sumsOffset,
+ ByteBuffer data, int dataOffset, int dataLength,
+ String fileName, long basePos) throws ChecksumException;
+
+ private static native void nativeComputeChunkedSums(
+ int bytesPerSum, int checksumType,
+ ByteBuffer sums, int sumsOffset,
+ ByteBuffer data, int dataOffset, int dataLength,
+ String fileName, long basePos, boolean verify);
+
+ private static native void nativeComputeChunkedSumsByteArray(
+ int bytesPerSum, int checksumType,
+ byte[] sums, int sumsOffset,
+ byte[] data, int dataOffset, int dataLength,
+ String fileName, long basePos, boolean verify);
+
+ // Copy the constants over from DataChecksum so that javah will pick them up
+ // and make them available in the native code header.
+ public static final int CHECKSUM_CRC32 = 1; //DataChecksum.CHECKSUM_CRC32
+ public static final int CHECKSUM_CRC32C = 2; //DataChecksum.CHECKSUM_CRC32C
+}
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/NativeLibraryChecker.java b/ratis-common/src/main/java/org/apache/ratis/util/NativeLibraryChecker.java
new file mode 100644
index 0000000000..b32702b3f5
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/NativeLibraryChecker.java
@@ -0,0 +1,64 @@
+/**
+ * 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.ratis.util;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class NativeLibraryChecker {
+ public static final Logger LOG = LoggerFactory.getLogger(NativeLibraryChecker.class);
+
+ /**
+ * A tool to test native library availability,
+ */
+ public static void main(String[] args) {
+ String usage = "NativeLibraryChecker [-a|-h]\n"
+ + " -a use -a to check all libraries are available\n"
+ + " by default just check ratis library (and\n"
+ + " winutils.exe on Windows OS) is available\n"
+ + " exit with error code 1 if check failed\n"
+ + " -h print this message\n";
+ if (args.length > 1 ||
+ (args.length == 1 &&
+ !(args[0].equals("-a") || args[0].equals("-h")))) {
+ System.err.println(usage);
+ ExitUtils.terminate(1, "Illegal arguments.", LOG);
+ }
+ if (args.length == 1) {
+ if (args[0].equals("-h")) {
+ System.out.println(usage);
+ return;
+ }
+ }
+ boolean nativeRatisLoaded = NativeCodeLoader.isNativeCodeLoaded();
+ String raftLibraryName = "";
+
+ if (nativeRatisLoaded) {
+ raftLibraryName = NativeCodeLoader.getLibraryName();
+ }
+
+ System.out.println("Native library checking:");
+ System.out.printf("raft: %b %s%n", nativeRatisLoaded, raftLibraryName);
+
+ if (!nativeRatisLoaded) {
+ // return 1 to indicated check failed
+ ExitUtils.terminate(1, "Failed to load native library.", LOG);
+ }
+ }
+}
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/NetUtils.java b/ratis-common/src/main/java/org/apache/ratis/util/NetUtils.java
new file mode 100644
index 0000000000..b6634b62dc
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/NetUtils.java
@@ -0,0 +1,151 @@
+/**
+ * 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.ratis.util;
+
+import com.google.common.base.Preconditions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.net.UnknownHostException;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public abstract class NetUtils {
+ public static final Logger LOG = LoggerFactory.getLogger(NetUtils.class);
+
+ public static abstract class StaticResolution {
+ /** Host -> resolved name */
+ private static final Map hostToResolved = new ConcurrentHashMap<>();
+
+ /** Adds a static resolution for host. */
+ public static void put(String host, String resolvedName) {
+ hostToResolved.put(host, resolvedName);
+ }
+
+ /** @return the resolved name, or null if the host is not found. */
+ public static String get(String host) {
+ return hostToResolved.get(host);
+ }
+ }
+
+ public static InetSocketAddress newInetSocketAddress(String address) {
+ if (address.charAt(0) == '/') {
+ address = address.substring(1);
+ }
+ try {
+ return createSocketAddr(address);
+ } catch (Exception e) {
+ LOG.trace("", e);
+ return null;
+ }
+ }
+
+ /**
+ * Util method to build socket addr from either:
+ * :
+ * ://:/
+ */
+ public static InetSocketAddress createSocketAddr(String target) {
+ return createSocketAddr(target, -1);
+ }
+
+ /**
+ * Util method to build socket addr from either:
+ *
+ * :
+ * ://:/
+ */
+ public static InetSocketAddress createSocketAddr(String target, int defaultPort) {
+ return createSocketAddr(target, defaultPort, null);
+ }
+
+ /**
+ * Create an InetSocketAddress from the given target string and
+ * default port. If the string cannot be parsed correctly, the
+ * configName parameter is used as part of the
+ * exception message, allowing the user to better diagnose
+ * the misconfiguration.
+ *
+ * @param target a string of either "host" or "host:port"
+ * @param defaultPort the default port if target does not
+ * include a port number
+ * @param propertyName the name of the configuration from which
+ * target was loaded. This is used in the
+ * exception message in the case that parsing fails.
+ */
+ public static InetSocketAddress createSocketAddr(
+ String target, int defaultPort, String propertyName) {
+ final String helpText = propertyName == null? ""
+ : " (property '" + propertyName + "')";
+ Preconditions.checkNotNull(target, "Target address cannot be null.%s", helpText);
+
+ target = target.trim();
+ boolean hasScheme = target.contains("://");
+ final URI uri;
+ try {
+ uri = hasScheme ? URI.create(target) : URI.create("dummyscheme://"+target);
+ } catch (IllegalArgumentException e) {
+ throw new IllegalArgumentException(
+ "Invalid host:port authority: " + target + helpText, e);
+ }
+
+ final String host = uri.getHost();
+ int port = uri.getPort();
+ if (port == -1) {
+ port = defaultPort;
+ }
+ final String path = uri.getPath();
+
+ if (host == null || port < 0
+ || (!hasScheme && path != null && !path.isEmpty())) {
+ throw new IllegalArgumentException(
+ "Invalid host:port authority: " + target + helpText);
+ }
+ return createSocketAddrForHost(host, port);
+ }
+
+ /**
+ * Create a socket address with the given host and port. The hostname
+ * might be replaced with another host that was set via
+ * {@link StaticResolution#put(String, String)}.
+ * @param host the hostname or IP use to instantiate the object
+ * @param port the port number
+ * @return InetSocketAddress
+ */
+ public static InetSocketAddress createSocketAddrForHost(String host, int port) {
+ String staticHost = StaticResolution.get(host);
+ String resolveHost = (staticHost != null) ? staticHost : host;
+
+ InetSocketAddress addr;
+ try {
+ InetAddress iaddr = InetAddress.getByName(resolveHost);
+ // if there is a static entry for the host, make the returned
+ // address look like the original given host
+ if (staticHost != null) {
+ iaddr = InetAddress.getByAddress(host, iaddr.getAddress());
+ }
+ addr = new InetSocketAddress(iaddr, port);
+ } catch (UnknownHostException e) {
+ addr = InetSocketAddress.createUnresolved(host, port);
+ }
+ return addr;
+ }
+}
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/PeerProxyMap.java b/ratis-common/src/main/java/org/apache/ratis/util/PeerProxyMap.java
new file mode 100644
index 0000000000..9466719303
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/PeerProxyMap.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.ratis.util;
+
+import com.google.common.base.Preconditions;
+
+import org.apache.ratis.protocol.RaftPeer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/** A map from peer id to peer and its proxy. */
+public class PeerProxyMap implements Closeable {
+ public static final Logger LOG = LoggerFactory.getLogger(PeerProxyMap.class);
+
+ /** Peer and its proxy. */
+ private class PeerAndProxy implements Closeable {
+ private final RaftPeer peer;
+ private volatile PROXY proxy = null;
+ private final LifeCycle lifeCycle;
+
+ PeerAndProxy(RaftPeer peer) {
+ this.peer = peer;
+ this.lifeCycle = new LifeCycle(peer);
+ }
+
+ RaftPeer getPeer() {
+ return peer;
+ }
+
+ PROXY getProxy() throws IOException {
+ if (proxy == null) {
+ synchronized (this) {
+ if (proxy == null) {
+ lifeCycle.startAndTransition(
+ () -> proxy = createProxy.apply(peer), IOException.class);
+ }
+ }
+ }
+ return proxy;
+ }
+
+ @Override
+ public synchronized void close() {
+ lifeCycle.checkStateAndClose(() -> {
+ if (proxy != null) {
+ try {
+ proxy.close();
+ } catch (IOException e) {
+ LOG.warn("Failed to close proxy for peer {}, proxy class: ",
+ peer, proxy.getClass());
+ }
+ }
+ });
+ }
+ }
+
+ private final Map peers = new ConcurrentHashMap<>();
+ private final Object resetLock = new Object();
+
+ private final CheckedFunction createProxy;
+
+ public PeerProxyMap(CheckedFunction createProxy) {
+ this.createProxy = createProxy;
+ }
+ public PeerProxyMap() {
+ this.createProxy = this::createProxyImpl;
+ }
+
+ public PROXY getProxy(String id) throws IOException {
+ PeerAndProxy p = peers.get(id);
+ if (p == null) {
+ synchronized (resetLock) {
+ p = peers.get(id);
+ }
+ }
+ Preconditions.checkNotNull(p, "Server %s not found; peers=%s",
+ id, peers.keySet());
+ return p.getProxy();
+ }
+
+ public void addPeers(Iterable newPeers) {
+ for(RaftPeer p : newPeers) {
+ peers.put(p.getId(), new PeerAndProxy(p));
+ }
+ }
+
+ public void putIfAbsent(RaftPeer p) {
+ peers.putIfAbsent(p.getId(), new PeerAndProxy(p));
+ }
+
+ public void resetProxy(String id) {
+ synchronized (resetLock) {
+ final PeerAndProxy pp = peers.remove(id);
+ final RaftPeer peer = pp.getPeer();
+ pp.close();
+ peers.put(id, new PeerAndProxy(peer));
+ }
+ }
+
+ public PROXY createProxyImpl(RaftPeer peer) throws IOException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void close() {
+ peers.values().forEach(PeerAndProxy::close);
+ }
+}
\ No newline at end of file
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/ProtoUtils.java b/ratis-common/src/main/java/org/apache/ratis/util/ProtoUtils.java
new file mode 100644
index 0000000000..8dc822b7c3
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/ProtoUtils.java
@@ -0,0 +1,147 @@
+/**
+ * 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.ratis.util;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+import org.apache.ratis.protocol.RaftPeer;
+import org.apache.ratis.shaded.com.google.protobuf.ByteString;
+import org.apache.ratis.shaded.com.google.protobuf.ServiceException;
+import org.apache.ratis.shaded.proto.RaftProtos.AppendEntriesReplyProto;
+import org.apache.ratis.shaded.proto.RaftProtos.LogEntryProto;
+import org.apache.ratis.shaded.proto.RaftProtos.RaftPeerProto;
+import org.apache.ratis.shaded.proto.RaftProtos.RaftRpcReplyProto;
+import org.apache.ratis.shaded.proto.RaftProtos.RaftRpcRequestProto;
+import org.apache.ratis.shaded.proto.RaftProtos.RequestVoteReplyProto;
+import org.apache.ratis.shaded.proto.RaftProtos.SMLogEntryProto;
+
+public class ProtoUtils {
+ public static ByteString toByteString(Object obj) {
+ final ByteString.Output byteOut = ByteString.newOutput();
+ try(final ObjectOutputStream objOut = new ObjectOutputStream(byteOut)) {
+ objOut.writeObject(obj);
+ } catch (IOException e) {
+ throw new IllegalStateException(
+ "Unexpected IOException when writing an object to a ByteString.", e);
+ }
+ return byteOut.toByteString();
+ }
+
+ public static Object toObject(ByteString bytes) {
+ try(final ObjectInputStream in = new ObjectInputStream(bytes.newInput())) {
+ return in.readObject();
+ } catch (IOException e) {
+ throw new IllegalStateException(
+ "Unexpected IOException when reading an object from a ByteString.", e);
+ } catch (ClassNotFoundException e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ public static ByteString toByteString(byte[] bytes) {
+ return toByteString(bytes, 0, bytes.length);
+ }
+
+ public static ByteString toByteString(byte[] bytes, int offset, int size) {
+ // return singleton to reduce object allocation
+ return bytes.length == 0 ?
+ ByteString.EMPTY : ByteString.copyFrom(bytes, offset, size);
+ }
+
+ public static RaftPeerProto toRaftPeerProto(RaftPeer peer) {
+ RaftPeerProto.Builder builder = RaftPeerProto.newBuilder()
+ .setId(peer.getId());
+ if (peer.getAddress() != null) {
+ builder.setAddress(peer.getAddress());
+ }
+ return builder.build();
+ }
+
+ public static RaftPeer toRaftPeer(RaftPeerProto p) {
+ return new RaftPeer(p.getId(), p.getAddress());
+ }
+
+ public static RaftPeer[] toRaftPeerArray(List protos) {
+ final RaftPeer[] peers = new RaftPeer[protos.size()];
+ for (int i = 0; i < peers.length; i++) {
+ peers[i] = toRaftPeer(protos.get(i));
+ }
+ return peers;
+ }
+
+ public static Iterable toRaftPeerProtos(
+ final Collection peers) {
+ return () -> new Iterator() {
+ final Iterator i = peers.iterator();
+
+ @Override
+ public boolean hasNext() {
+ return i.hasNext();
+ }
+
+ @Override
+ public RaftPeerProto next() {
+ return toRaftPeerProto(i.next());
+ }
+ };
+ }
+
+ public static boolean isConfigurationLogEntry(LogEntryProto entry) {
+ return entry.getLogEntryBodyCase() ==
+ LogEntryProto.LogEntryBodyCase.CONFIGURATIONENTRY;
+ }
+
+ public static LogEntryProto toLogEntryProto(
+ SMLogEntryProto operation, long term, long index) {
+ return LogEntryProto.newBuilder().setTerm(term).setIndex(index)
+ .setSmLogEntry(operation)
+ .build();
+ }
+
+ public static IOException toIOException(ServiceException se) {
+ final Throwable t = se.getCause();
+ if (t == null) {
+ return new IOException(se);
+ }
+ return t instanceof IOException? (IOException)t : new IOException(se);
+ }
+
+ public static String toString(RaftRpcRequestProto proto) {
+ return proto.getRequestorId() + "->" + proto.getReplyId()
+ + "#" + proto.getSeqNum();
+ }
+
+ public static String toString(RaftRpcReplyProto proto) {
+ return proto.getRequestorId() + "<-" + proto.getReplyId()
+ + "#" + proto.getSeqNum() + ":"
+ + (proto.getSuccess()? "OK": "FAIL");
+ }
+ public static String toString(RequestVoteReplyProto proto) {
+ return toString(proto.getServerReply()) + "-t" + proto.getTerm();
+ }
+ public static String toString(AppendEntriesReplyProto proto) {
+ return toString(proto.getServerReply()) + "-t" + proto.getTerm()
+ + ", nextIndex=" + proto.getNextIndex()
+ + ", result: " + proto.getResult();
+ }
+}
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/PureJavaCrc32.java b/ratis-common/src/main/java/org/apache/ratis/util/PureJavaCrc32.java
new file mode 100644
index 0000000000..d21b56a023
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/PureJavaCrc32.java
@@ -0,0 +1,619 @@
+/**
+ * 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.ratis.util;
+
+import java.util.zip.Checksum;
+
+/**
+ * A pure-java implementation of the CRC32 checksum that uses
+ * the same polynomial as the built-in native CRC32.
+ *
+ * This is to avoid the JNI overhead for certain uses of Checksumming
+ * where many small pieces of data are checksummed in succession.
+ *
+ * The current version is ~10x to 1.8x as fast as Sun's native
+ * java.util.zip.CRC32 in Java 1.6
+ *
+ * @see java.util.zip.CRC32
+ */
+public class PureJavaCrc32 implements Checksum {
+
+ /** the current CRC value, bit-flipped */
+ private int crc;
+
+ /** Create a new PureJavaCrc32 object. */
+ public PureJavaCrc32() {
+ reset();
+ }
+
+ @Override
+ public long getValue() {
+ return (~crc) & 0xffffffffL;
+ }
+
+ @Override
+ public void reset() {
+ crc = 0xffffffff;
+ }
+
+ @Override
+ public void update(final byte[] b, final int offset, final int len) {
+ int localCrc = crc;
+
+ final int remainder = len & 0x7;
+ int i = offset;
+ for(final int end = offset + len - remainder; i < end; i += 8) {
+ final int x = localCrc
+ ^ ((((b[i ] << 24) >>> 24) + ((b[i+1] << 24) >>> 16))
+ + (((b[i+2] << 24) >>> 8 ) + (b[i+3] << 24)));
+
+ localCrc = ((T[((x << 24) >>> 24) + 0x700] ^ T[((x << 16) >>> 24) + 0x600])
+ ^ (T[((x << 8) >>> 24) + 0x500] ^ T[ (x >>> 24) + 0x400]))
+ ^ ((T[((b[i+4] << 24) >>> 24) + 0x300] ^ T[((b[i+5] << 24) >>> 24) + 0x200])
+ ^ (T[((b[i+6] << 24) >>> 24) + 0x100] ^ T[((b[i+7] << 24) >>> 24)]));
+ }
+
+ /* loop unroll - duff's device style */
+ switch(remainder) {
+ case 7: localCrc = (localCrc >>> 8) ^ T[((localCrc ^ b[i++]) << 24) >>> 24];
+ case 6: localCrc = (localCrc >>> 8) ^ T[((localCrc ^ b[i++]) << 24) >>> 24];
+ case 5: localCrc = (localCrc >>> 8) ^ T[((localCrc ^ b[i++]) << 24) >>> 24];
+ case 4: localCrc = (localCrc >>> 8) ^ T[((localCrc ^ b[i++]) << 24) >>> 24];
+ case 3: localCrc = (localCrc >>> 8) ^ T[((localCrc ^ b[i++]) << 24) >>> 24];
+ case 2: localCrc = (localCrc >>> 8) ^ T[((localCrc ^ b[i++]) << 24) >>> 24];
+ case 1: localCrc = (localCrc >>> 8) ^ T[((localCrc ^ b[i++]) << 24) >>> 24];
+ default:
+ /* nothing */
+ }
+
+ // Publish crc out to object
+ crc = localCrc;
+ }
+
+ @Override
+ final public void update(int b) {
+ crc = (crc >>> 8) ^ T[(((crc ^ b) << 24) >>> 24)];
+ }
+
+ /*
+ * CRC-32 lookup tables generated by the polynomial 0xEDB88320.
+ * See also TestPureJavaCrc32.Table.
+ */
+ private static final int[] T = new int[] {
+ /* T8_0 */
+ 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
+ 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
+ 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
+ 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
+ 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
+ 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
+ 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
+ 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
+ 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
+ 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+ 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
+ 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
+ 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
+ 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
+ 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
+ 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
+ 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
+ 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+ 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
+ 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
+ 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
+ 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
+ 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
+ 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+ 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
+ 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
+ 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
+ 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
+ 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
+ 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+ 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
+ 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
+ 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
+ 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
+ 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
+ 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+ 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
+ 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
+ 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
+ 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
+ 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
+ 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+ 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
+ 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
+ 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+ 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
+ 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
+ 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+ 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
+ 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
+ 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
+ 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
+ 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
+ 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+ 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
+ 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
+ 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
+ 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
+ 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
+ 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+ 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
+ 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
+ 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
+ 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D,
+ /* T8_1 */
+ 0x00000000, 0x191B3141, 0x32366282, 0x2B2D53C3,
+ 0x646CC504, 0x7D77F445, 0x565AA786, 0x4F4196C7,
+ 0xC8D98A08, 0xD1C2BB49, 0xFAEFE88A, 0xE3F4D9CB,
+ 0xACB54F0C, 0xB5AE7E4D, 0x9E832D8E, 0x87981CCF,
+ 0x4AC21251, 0x53D92310, 0x78F470D3, 0x61EF4192,
+ 0x2EAED755, 0x37B5E614, 0x1C98B5D7, 0x05838496,
+ 0x821B9859, 0x9B00A918, 0xB02DFADB, 0xA936CB9A,
+ 0xE6775D5D, 0xFF6C6C1C, 0xD4413FDF, 0xCD5A0E9E,
+ 0x958424A2, 0x8C9F15E3, 0xA7B24620, 0xBEA97761,
+ 0xF1E8E1A6, 0xE8F3D0E7, 0xC3DE8324, 0xDAC5B265,
+ 0x5D5DAEAA, 0x44469FEB, 0x6F6BCC28, 0x7670FD69,
+ 0x39316BAE, 0x202A5AEF, 0x0B07092C, 0x121C386D,
+ 0xDF4636F3, 0xC65D07B2, 0xED705471, 0xF46B6530,
+ 0xBB2AF3F7, 0xA231C2B6, 0x891C9175, 0x9007A034,
+ 0x179FBCFB, 0x0E848DBA, 0x25A9DE79, 0x3CB2EF38,
+ 0x73F379FF, 0x6AE848BE, 0x41C51B7D, 0x58DE2A3C,
+ 0xF0794F05, 0xE9627E44, 0xC24F2D87, 0xDB541CC6,
+ 0x94158A01, 0x8D0EBB40, 0xA623E883, 0xBF38D9C2,
+ 0x38A0C50D, 0x21BBF44C, 0x0A96A78F, 0x138D96CE,
+ 0x5CCC0009, 0x45D73148, 0x6EFA628B, 0x77E153CA,
+ 0xBABB5D54, 0xA3A06C15, 0x888D3FD6, 0x91960E97,
+ 0xDED79850, 0xC7CCA911, 0xECE1FAD2, 0xF5FACB93,
+ 0x7262D75C, 0x6B79E61D, 0x4054B5DE, 0x594F849F,
+ 0x160E1258, 0x0F152319, 0x243870DA, 0x3D23419B,
+ 0x65FD6BA7, 0x7CE65AE6, 0x57CB0925, 0x4ED03864,
+ 0x0191AEA3, 0x188A9FE2, 0x33A7CC21, 0x2ABCFD60,
+ 0xAD24E1AF, 0xB43FD0EE, 0x9F12832D, 0x8609B26C,
+ 0xC94824AB, 0xD05315EA, 0xFB7E4629, 0xE2657768,
+ 0x2F3F79F6, 0x362448B7, 0x1D091B74, 0x04122A35,
+ 0x4B53BCF2, 0x52488DB3, 0x7965DE70, 0x607EEF31,
+ 0xE7E6F3FE, 0xFEFDC2BF, 0xD5D0917C, 0xCCCBA03D,
+ 0x838A36FA, 0x9A9107BB, 0xB1BC5478, 0xA8A76539,
+ 0x3B83984B, 0x2298A90A, 0x09B5FAC9, 0x10AECB88,
+ 0x5FEF5D4F, 0x46F46C0E, 0x6DD93FCD, 0x74C20E8C,
+ 0xF35A1243, 0xEA412302, 0xC16C70C1, 0xD8774180,
+ 0x9736D747, 0x8E2DE606, 0xA500B5C5, 0xBC1B8484,
+ 0x71418A1A, 0x685ABB5B, 0x4377E898, 0x5A6CD9D9,
+ 0x152D4F1E, 0x0C367E5F, 0x271B2D9C, 0x3E001CDD,
+ 0xB9980012, 0xA0833153, 0x8BAE6290, 0x92B553D1,
+ 0xDDF4C516, 0xC4EFF457, 0xEFC2A794, 0xF6D996D5,
+ 0xAE07BCE9, 0xB71C8DA8, 0x9C31DE6B, 0x852AEF2A,
+ 0xCA6B79ED, 0xD37048AC, 0xF85D1B6F, 0xE1462A2E,
+ 0x66DE36E1, 0x7FC507A0, 0x54E85463, 0x4DF36522,
+ 0x02B2F3E5, 0x1BA9C2A4, 0x30849167, 0x299FA026,
+ 0xE4C5AEB8, 0xFDDE9FF9, 0xD6F3CC3A, 0xCFE8FD7B,
+ 0x80A96BBC, 0x99B25AFD, 0xB29F093E, 0xAB84387F,
+ 0x2C1C24B0, 0x350715F1, 0x1E2A4632, 0x07317773,
+ 0x4870E1B4, 0x516BD0F5, 0x7A468336, 0x635DB277,
+ 0xCBFAD74E, 0xD2E1E60F, 0xF9CCB5CC, 0xE0D7848D,
+ 0xAF96124A, 0xB68D230B, 0x9DA070C8, 0x84BB4189,
+ 0x03235D46, 0x1A386C07, 0x31153FC4, 0x280E0E85,
+ 0x674F9842, 0x7E54A903, 0x5579FAC0, 0x4C62CB81,
+ 0x8138C51F, 0x9823F45E, 0xB30EA79D, 0xAA1596DC,
+ 0xE554001B, 0xFC4F315A, 0xD7626299, 0xCE7953D8,
+ 0x49E14F17, 0x50FA7E56, 0x7BD72D95, 0x62CC1CD4,
+ 0x2D8D8A13, 0x3496BB52, 0x1FBBE891, 0x06A0D9D0,
+ 0x5E7EF3EC, 0x4765C2AD, 0x6C48916E, 0x7553A02F,
+ 0x3A1236E8, 0x230907A9, 0x0824546A, 0x113F652B,
+ 0x96A779E4, 0x8FBC48A5, 0xA4911B66, 0xBD8A2A27,
+ 0xF2CBBCE0, 0xEBD08DA1, 0xC0FDDE62, 0xD9E6EF23,
+ 0x14BCE1BD, 0x0DA7D0FC, 0x268A833F, 0x3F91B27E,
+ 0x70D024B9, 0x69CB15F8, 0x42E6463B, 0x5BFD777A,
+ 0xDC656BB5, 0xC57E5AF4, 0xEE530937, 0xF7483876,
+ 0xB809AEB1, 0xA1129FF0, 0x8A3FCC33, 0x9324FD72,
+ /* T8_2 */
+ 0x00000000, 0x01C26A37, 0x0384D46E, 0x0246BE59,
+ 0x0709A8DC, 0x06CBC2EB, 0x048D7CB2, 0x054F1685,
+ 0x0E1351B8, 0x0FD13B8F, 0x0D9785D6, 0x0C55EFE1,
+ 0x091AF964, 0x08D89353, 0x0A9E2D0A, 0x0B5C473D,
+ 0x1C26A370, 0x1DE4C947, 0x1FA2771E, 0x1E601D29,
+ 0x1B2F0BAC, 0x1AED619B, 0x18ABDFC2, 0x1969B5F5,
+ 0x1235F2C8, 0x13F798FF, 0x11B126A6, 0x10734C91,
+ 0x153C5A14, 0x14FE3023, 0x16B88E7A, 0x177AE44D,
+ 0x384D46E0, 0x398F2CD7, 0x3BC9928E, 0x3A0BF8B9,
+ 0x3F44EE3C, 0x3E86840B, 0x3CC03A52, 0x3D025065,
+ 0x365E1758, 0x379C7D6F, 0x35DAC336, 0x3418A901,
+ 0x3157BF84, 0x3095D5B3, 0x32D36BEA, 0x331101DD,
+ 0x246BE590, 0x25A98FA7, 0x27EF31FE, 0x262D5BC9,
+ 0x23624D4C, 0x22A0277B, 0x20E69922, 0x2124F315,
+ 0x2A78B428, 0x2BBADE1F, 0x29FC6046, 0x283E0A71,
+ 0x2D711CF4, 0x2CB376C3, 0x2EF5C89A, 0x2F37A2AD,
+ 0x709A8DC0, 0x7158E7F7, 0x731E59AE, 0x72DC3399,
+ 0x7793251C, 0x76514F2B, 0x7417F172, 0x75D59B45,
+ 0x7E89DC78, 0x7F4BB64F, 0x7D0D0816, 0x7CCF6221,
+ 0x798074A4, 0x78421E93, 0x7A04A0CA, 0x7BC6CAFD,
+ 0x6CBC2EB0, 0x6D7E4487, 0x6F38FADE, 0x6EFA90E9,
+ 0x6BB5866C, 0x6A77EC5B, 0x68315202, 0x69F33835,
+ 0x62AF7F08, 0x636D153F, 0x612BAB66, 0x60E9C151,
+ 0x65A6D7D4, 0x6464BDE3, 0x662203BA, 0x67E0698D,
+ 0x48D7CB20, 0x4915A117, 0x4B531F4E, 0x4A917579,
+ 0x4FDE63FC, 0x4E1C09CB, 0x4C5AB792, 0x4D98DDA5,
+ 0x46C49A98, 0x4706F0AF, 0x45404EF6, 0x448224C1,
+ 0x41CD3244, 0x400F5873, 0x4249E62A, 0x438B8C1D,
+ 0x54F16850, 0x55330267, 0x5775BC3E, 0x56B7D609,
+ 0x53F8C08C, 0x523AAABB, 0x507C14E2, 0x51BE7ED5,
+ 0x5AE239E8, 0x5B2053DF, 0x5966ED86, 0x58A487B1,
+ 0x5DEB9134, 0x5C29FB03, 0x5E6F455A, 0x5FAD2F6D,
+ 0xE1351B80, 0xE0F771B7, 0xE2B1CFEE, 0xE373A5D9,
+ 0xE63CB35C, 0xE7FED96B, 0xE5B86732, 0xE47A0D05,
+ 0xEF264A38, 0xEEE4200F, 0xECA29E56, 0xED60F461,
+ 0xE82FE2E4, 0xE9ED88D3, 0xEBAB368A, 0xEA695CBD,
+ 0xFD13B8F0, 0xFCD1D2C7, 0xFE976C9E, 0xFF5506A9,
+ 0xFA1A102C, 0xFBD87A1B, 0xF99EC442, 0xF85CAE75,
+ 0xF300E948, 0xF2C2837F, 0xF0843D26, 0xF1465711,
+ 0xF4094194, 0xF5CB2BA3, 0xF78D95FA, 0xF64FFFCD,
+ 0xD9785D60, 0xD8BA3757, 0xDAFC890E, 0xDB3EE339,
+ 0xDE71F5BC, 0xDFB39F8B, 0xDDF521D2, 0xDC374BE5,
+ 0xD76B0CD8, 0xD6A966EF, 0xD4EFD8B6, 0xD52DB281,
+ 0xD062A404, 0xD1A0CE33, 0xD3E6706A, 0xD2241A5D,
+ 0xC55EFE10, 0xC49C9427, 0xC6DA2A7E, 0xC7184049,
+ 0xC25756CC, 0xC3953CFB, 0xC1D382A2, 0xC011E895,
+ 0xCB4DAFA8, 0xCA8FC59F, 0xC8C97BC6, 0xC90B11F1,
+ 0xCC440774, 0xCD866D43, 0xCFC0D31A, 0xCE02B92D,
+ 0x91AF9640, 0x906DFC77, 0x922B422E, 0x93E92819,
+ 0x96A63E9C, 0x976454AB, 0x9522EAF2, 0x94E080C5,
+ 0x9FBCC7F8, 0x9E7EADCF, 0x9C381396, 0x9DFA79A1,
+ 0x98B56F24, 0x99770513, 0x9B31BB4A, 0x9AF3D17D,
+ 0x8D893530, 0x8C4B5F07, 0x8E0DE15E, 0x8FCF8B69,
+ 0x8A809DEC, 0x8B42F7DB, 0x89044982, 0x88C623B5,
+ 0x839A6488, 0x82580EBF, 0x801EB0E6, 0x81DCDAD1,
+ 0x8493CC54, 0x8551A663, 0x8717183A, 0x86D5720D,
+ 0xA9E2D0A0, 0xA820BA97, 0xAA6604CE, 0xABA46EF9,
+ 0xAEEB787C, 0xAF29124B, 0xAD6FAC12, 0xACADC625,
+ 0xA7F18118, 0xA633EB2F, 0xA4755576, 0xA5B73F41,
+ 0xA0F829C4, 0xA13A43F3, 0xA37CFDAA, 0xA2BE979D,
+ 0xB5C473D0, 0xB40619E7, 0xB640A7BE, 0xB782CD89,
+ 0xB2CDDB0C, 0xB30FB13B, 0xB1490F62, 0xB08B6555,
+ 0xBBD72268, 0xBA15485F, 0xB853F606, 0xB9919C31,
+ 0xBCDE8AB4, 0xBD1CE083, 0xBF5A5EDA, 0xBE9834ED,
+ /* T8_3 */
+ 0x00000000, 0xB8BC6765, 0xAA09C88B, 0x12B5AFEE,
+ 0x8F629757, 0x37DEF032, 0x256B5FDC, 0x9DD738B9,
+ 0xC5B428EF, 0x7D084F8A, 0x6FBDE064, 0xD7018701,
+ 0x4AD6BFB8, 0xF26AD8DD, 0xE0DF7733, 0x58631056,
+ 0x5019579F, 0xE8A530FA, 0xFA109F14, 0x42ACF871,
+ 0xDF7BC0C8, 0x67C7A7AD, 0x75720843, 0xCDCE6F26,
+ 0x95AD7F70, 0x2D111815, 0x3FA4B7FB, 0x8718D09E,
+ 0x1ACFE827, 0xA2738F42, 0xB0C620AC, 0x087A47C9,
+ 0xA032AF3E, 0x188EC85B, 0x0A3B67B5, 0xB28700D0,
+ 0x2F503869, 0x97EC5F0C, 0x8559F0E2, 0x3DE59787,
+ 0x658687D1, 0xDD3AE0B4, 0xCF8F4F5A, 0x7733283F,
+ 0xEAE41086, 0x525877E3, 0x40EDD80D, 0xF851BF68,
+ 0xF02BF8A1, 0x48979FC4, 0x5A22302A, 0xE29E574F,
+ 0x7F496FF6, 0xC7F50893, 0xD540A77D, 0x6DFCC018,
+ 0x359FD04E, 0x8D23B72B, 0x9F9618C5, 0x272A7FA0,
+ 0xBAFD4719, 0x0241207C, 0x10F48F92, 0xA848E8F7,
+ 0x9B14583D, 0x23A83F58, 0x311D90B6, 0x89A1F7D3,
+ 0x1476CF6A, 0xACCAA80F, 0xBE7F07E1, 0x06C36084,
+ 0x5EA070D2, 0xE61C17B7, 0xF4A9B859, 0x4C15DF3C,
+ 0xD1C2E785, 0x697E80E0, 0x7BCB2F0E, 0xC377486B,
+ 0xCB0D0FA2, 0x73B168C7, 0x6104C729, 0xD9B8A04C,
+ 0x446F98F5, 0xFCD3FF90, 0xEE66507E, 0x56DA371B,
+ 0x0EB9274D, 0xB6054028, 0xA4B0EFC6, 0x1C0C88A3,
+ 0x81DBB01A, 0x3967D77F, 0x2BD27891, 0x936E1FF4,
+ 0x3B26F703, 0x839A9066, 0x912F3F88, 0x299358ED,
+ 0xB4446054, 0x0CF80731, 0x1E4DA8DF, 0xA6F1CFBA,
+ 0xFE92DFEC, 0x462EB889, 0x549B1767, 0xEC277002,
+ 0x71F048BB, 0xC94C2FDE, 0xDBF98030, 0x6345E755,
+ 0x6B3FA09C, 0xD383C7F9, 0xC1366817, 0x798A0F72,
+ 0xE45D37CB, 0x5CE150AE, 0x4E54FF40, 0xF6E89825,
+ 0xAE8B8873, 0x1637EF16, 0x048240F8, 0xBC3E279D,
+ 0x21E91F24, 0x99557841, 0x8BE0D7AF, 0x335CB0CA,
+ 0xED59B63B, 0x55E5D15E, 0x47507EB0, 0xFFEC19D5,
+ 0x623B216C, 0xDA874609, 0xC832E9E7, 0x708E8E82,
+ 0x28ED9ED4, 0x9051F9B1, 0x82E4565F, 0x3A58313A,
+ 0xA78F0983, 0x1F336EE6, 0x0D86C108, 0xB53AA66D,
+ 0xBD40E1A4, 0x05FC86C1, 0x1749292F, 0xAFF54E4A,
+ 0x322276F3, 0x8A9E1196, 0x982BBE78, 0x2097D91D,
+ 0x78F4C94B, 0xC048AE2E, 0xD2FD01C0, 0x6A4166A5,
+ 0xF7965E1C, 0x4F2A3979, 0x5D9F9697, 0xE523F1F2,
+ 0x4D6B1905, 0xF5D77E60, 0xE762D18E, 0x5FDEB6EB,
+ 0xC2098E52, 0x7AB5E937, 0x680046D9, 0xD0BC21BC,
+ 0x88DF31EA, 0x3063568F, 0x22D6F961, 0x9A6A9E04,
+ 0x07BDA6BD, 0xBF01C1D8, 0xADB46E36, 0x15080953,
+ 0x1D724E9A, 0xA5CE29FF, 0xB77B8611, 0x0FC7E174,
+ 0x9210D9CD, 0x2AACBEA8, 0x38191146, 0x80A57623,
+ 0xD8C66675, 0x607A0110, 0x72CFAEFE, 0xCA73C99B,
+ 0x57A4F122, 0xEF189647, 0xFDAD39A9, 0x45115ECC,
+ 0x764DEE06, 0xCEF18963, 0xDC44268D, 0x64F841E8,
+ 0xF92F7951, 0x41931E34, 0x5326B1DA, 0xEB9AD6BF,
+ 0xB3F9C6E9, 0x0B45A18C, 0x19F00E62, 0xA14C6907,
+ 0x3C9B51BE, 0x842736DB, 0x96929935, 0x2E2EFE50,
+ 0x2654B999, 0x9EE8DEFC, 0x8C5D7112, 0x34E11677,
+ 0xA9362ECE, 0x118A49AB, 0x033FE645, 0xBB838120,
+ 0xE3E09176, 0x5B5CF613, 0x49E959FD, 0xF1553E98,
+ 0x6C820621, 0xD43E6144, 0xC68BCEAA, 0x7E37A9CF,
+ 0xD67F4138, 0x6EC3265D, 0x7C7689B3, 0xC4CAEED6,
+ 0x591DD66F, 0xE1A1B10A, 0xF3141EE4, 0x4BA87981,
+ 0x13CB69D7, 0xAB770EB2, 0xB9C2A15C, 0x017EC639,
+ 0x9CA9FE80, 0x241599E5, 0x36A0360B, 0x8E1C516E,
+ 0x866616A7, 0x3EDA71C2, 0x2C6FDE2C, 0x94D3B949,
+ 0x090481F0, 0xB1B8E695, 0xA30D497B, 0x1BB12E1E,
+ 0x43D23E48, 0xFB6E592D, 0xE9DBF6C3, 0x516791A6,
+ 0xCCB0A91F, 0x740CCE7A, 0x66B96194, 0xDE0506F1,
+ /* T8_4 */
+ 0x00000000, 0x3D6029B0, 0x7AC05360, 0x47A07AD0,
+ 0xF580A6C0, 0xC8E08F70, 0x8F40F5A0, 0xB220DC10,
+ 0x30704BC1, 0x0D106271, 0x4AB018A1, 0x77D03111,
+ 0xC5F0ED01, 0xF890C4B1, 0xBF30BE61, 0x825097D1,
+ 0x60E09782, 0x5D80BE32, 0x1A20C4E2, 0x2740ED52,
+ 0x95603142, 0xA80018F2, 0xEFA06222, 0xD2C04B92,
+ 0x5090DC43, 0x6DF0F5F3, 0x2A508F23, 0x1730A693,
+ 0xA5107A83, 0x98705333, 0xDFD029E3, 0xE2B00053,
+ 0xC1C12F04, 0xFCA106B4, 0xBB017C64, 0x866155D4,
+ 0x344189C4, 0x0921A074, 0x4E81DAA4, 0x73E1F314,
+ 0xF1B164C5, 0xCCD14D75, 0x8B7137A5, 0xB6111E15,
+ 0x0431C205, 0x3951EBB5, 0x7EF19165, 0x4391B8D5,
+ 0xA121B886, 0x9C419136, 0xDBE1EBE6, 0xE681C256,
+ 0x54A11E46, 0x69C137F6, 0x2E614D26, 0x13016496,
+ 0x9151F347, 0xAC31DAF7, 0xEB91A027, 0xD6F18997,
+ 0x64D15587, 0x59B17C37, 0x1E1106E7, 0x23712F57,
+ 0x58F35849, 0x659371F9, 0x22330B29, 0x1F532299,
+ 0xAD73FE89, 0x9013D739, 0xD7B3ADE9, 0xEAD38459,
+ 0x68831388, 0x55E33A38, 0x124340E8, 0x2F236958,
+ 0x9D03B548, 0xA0639CF8, 0xE7C3E628, 0xDAA3CF98,
+ 0x3813CFCB, 0x0573E67B, 0x42D39CAB, 0x7FB3B51B,
+ 0xCD93690B, 0xF0F340BB, 0xB7533A6B, 0x8A3313DB,
+ 0x0863840A, 0x3503ADBA, 0x72A3D76A, 0x4FC3FEDA,
+ 0xFDE322CA, 0xC0830B7A, 0x872371AA, 0xBA43581A,
+ 0x9932774D, 0xA4525EFD, 0xE3F2242D, 0xDE920D9D,
+ 0x6CB2D18D, 0x51D2F83D, 0x167282ED, 0x2B12AB5D,
+ 0xA9423C8C, 0x9422153C, 0xD3826FEC, 0xEEE2465C,
+ 0x5CC29A4C, 0x61A2B3FC, 0x2602C92C, 0x1B62E09C,
+ 0xF9D2E0CF, 0xC4B2C97F, 0x8312B3AF, 0xBE729A1F,
+ 0x0C52460F, 0x31326FBF, 0x7692156F, 0x4BF23CDF,
+ 0xC9A2AB0E, 0xF4C282BE, 0xB362F86E, 0x8E02D1DE,
+ 0x3C220DCE, 0x0142247E, 0x46E25EAE, 0x7B82771E,
+ 0xB1E6B092, 0x8C869922, 0xCB26E3F2, 0xF646CA42,
+ 0x44661652, 0x79063FE2, 0x3EA64532, 0x03C66C82,
+ 0x8196FB53, 0xBCF6D2E3, 0xFB56A833, 0xC6368183,
+ 0x74165D93, 0x49767423, 0x0ED60EF3, 0x33B62743,
+ 0xD1062710, 0xEC660EA0, 0xABC67470, 0x96A65DC0,
+ 0x248681D0, 0x19E6A860, 0x5E46D2B0, 0x6326FB00,
+ 0xE1766CD1, 0xDC164561, 0x9BB63FB1, 0xA6D61601,
+ 0x14F6CA11, 0x2996E3A1, 0x6E369971, 0x5356B0C1,
+ 0x70279F96, 0x4D47B626, 0x0AE7CCF6, 0x3787E546,
+ 0x85A73956, 0xB8C710E6, 0xFF676A36, 0xC2074386,
+ 0x4057D457, 0x7D37FDE7, 0x3A978737, 0x07F7AE87,
+ 0xB5D77297, 0x88B75B27, 0xCF1721F7, 0xF2770847,
+ 0x10C70814, 0x2DA721A4, 0x6A075B74, 0x576772C4,
+ 0xE547AED4, 0xD8278764, 0x9F87FDB4, 0xA2E7D404,
+ 0x20B743D5, 0x1DD76A65, 0x5A7710B5, 0x67173905,
+ 0xD537E515, 0xE857CCA5, 0xAFF7B675, 0x92979FC5,
+ 0xE915E8DB, 0xD475C16B, 0x93D5BBBB, 0xAEB5920B,
+ 0x1C954E1B, 0x21F567AB, 0x66551D7B, 0x5B3534CB,
+ 0xD965A31A, 0xE4058AAA, 0xA3A5F07A, 0x9EC5D9CA,
+ 0x2CE505DA, 0x11852C6A, 0x562556BA, 0x6B457F0A,
+ 0x89F57F59, 0xB49556E9, 0xF3352C39, 0xCE550589,
+ 0x7C75D999, 0x4115F029, 0x06B58AF9, 0x3BD5A349,
+ 0xB9853498, 0x84E51D28, 0xC34567F8, 0xFE254E48,
+ 0x4C059258, 0x7165BBE8, 0x36C5C138, 0x0BA5E888,
+ 0x28D4C7DF, 0x15B4EE6F, 0x521494BF, 0x6F74BD0F,
+ 0xDD54611F, 0xE03448AF, 0xA794327F, 0x9AF41BCF,
+ 0x18A48C1E, 0x25C4A5AE, 0x6264DF7E, 0x5F04F6CE,
+ 0xED242ADE, 0xD044036E, 0x97E479BE, 0xAA84500E,
+ 0x4834505D, 0x755479ED, 0x32F4033D, 0x0F942A8D,
+ 0xBDB4F69D, 0x80D4DF2D, 0xC774A5FD, 0xFA148C4D,
+ 0x78441B9C, 0x4524322C, 0x028448FC, 0x3FE4614C,
+ 0x8DC4BD5C, 0xB0A494EC, 0xF704EE3C, 0xCA64C78C,
+ /* T8_5 */
+ 0x00000000, 0xCB5CD3A5, 0x4DC8A10B, 0x869472AE,
+ 0x9B914216, 0x50CD91B3, 0xD659E31D, 0x1D0530B8,
+ 0xEC53826D, 0x270F51C8, 0xA19B2366, 0x6AC7F0C3,
+ 0x77C2C07B, 0xBC9E13DE, 0x3A0A6170, 0xF156B2D5,
+ 0x03D6029B, 0xC88AD13E, 0x4E1EA390, 0x85427035,
+ 0x9847408D, 0x531B9328, 0xD58FE186, 0x1ED33223,
+ 0xEF8580F6, 0x24D95353, 0xA24D21FD, 0x6911F258,
+ 0x7414C2E0, 0xBF481145, 0x39DC63EB, 0xF280B04E,
+ 0x07AC0536, 0xCCF0D693, 0x4A64A43D, 0x81387798,
+ 0x9C3D4720, 0x57619485, 0xD1F5E62B, 0x1AA9358E,
+ 0xEBFF875B, 0x20A354FE, 0xA6372650, 0x6D6BF5F5,
+ 0x706EC54D, 0xBB3216E8, 0x3DA66446, 0xF6FAB7E3,
+ 0x047A07AD, 0xCF26D408, 0x49B2A6A6, 0x82EE7503,
+ 0x9FEB45BB, 0x54B7961E, 0xD223E4B0, 0x197F3715,
+ 0xE82985C0, 0x23755665, 0xA5E124CB, 0x6EBDF76E,
+ 0x73B8C7D6, 0xB8E41473, 0x3E7066DD, 0xF52CB578,
+ 0x0F580A6C, 0xC404D9C9, 0x4290AB67, 0x89CC78C2,
+ 0x94C9487A, 0x5F959BDF, 0xD901E971, 0x125D3AD4,
+ 0xE30B8801, 0x28575BA4, 0xAEC3290A, 0x659FFAAF,
+ 0x789ACA17, 0xB3C619B2, 0x35526B1C, 0xFE0EB8B9,
+ 0x0C8E08F7, 0xC7D2DB52, 0x4146A9FC, 0x8A1A7A59,
+ 0x971F4AE1, 0x5C439944, 0xDAD7EBEA, 0x118B384F,
+ 0xE0DD8A9A, 0x2B81593F, 0xAD152B91, 0x6649F834,
+ 0x7B4CC88C, 0xB0101B29, 0x36846987, 0xFDD8BA22,
+ 0x08F40F5A, 0xC3A8DCFF, 0x453CAE51, 0x8E607DF4,
+ 0x93654D4C, 0x58399EE9, 0xDEADEC47, 0x15F13FE2,
+ 0xE4A78D37, 0x2FFB5E92, 0xA96F2C3C, 0x6233FF99,
+ 0x7F36CF21, 0xB46A1C84, 0x32FE6E2A, 0xF9A2BD8F,
+ 0x0B220DC1, 0xC07EDE64, 0x46EAACCA, 0x8DB67F6F,
+ 0x90B34FD7, 0x5BEF9C72, 0xDD7BEEDC, 0x16273D79,
+ 0xE7718FAC, 0x2C2D5C09, 0xAAB92EA7, 0x61E5FD02,
+ 0x7CE0CDBA, 0xB7BC1E1F, 0x31286CB1, 0xFA74BF14,
+ 0x1EB014D8, 0xD5ECC77D, 0x5378B5D3, 0x98246676,
+ 0x852156CE, 0x4E7D856B, 0xC8E9F7C5, 0x03B52460,
+ 0xF2E396B5, 0x39BF4510, 0xBF2B37BE, 0x7477E41B,
+ 0x6972D4A3, 0xA22E0706, 0x24BA75A8, 0xEFE6A60D,
+ 0x1D661643, 0xD63AC5E6, 0x50AEB748, 0x9BF264ED,
+ 0x86F75455, 0x4DAB87F0, 0xCB3FF55E, 0x006326FB,
+ 0xF135942E, 0x3A69478B, 0xBCFD3525, 0x77A1E680,
+ 0x6AA4D638, 0xA1F8059D, 0x276C7733, 0xEC30A496,
+ 0x191C11EE, 0xD240C24B, 0x54D4B0E5, 0x9F886340,
+ 0x828D53F8, 0x49D1805D, 0xCF45F2F3, 0x04192156,
+ 0xF54F9383, 0x3E134026, 0xB8873288, 0x73DBE12D,
+ 0x6EDED195, 0xA5820230, 0x2316709E, 0xE84AA33B,
+ 0x1ACA1375, 0xD196C0D0, 0x5702B27E, 0x9C5E61DB,
+ 0x815B5163, 0x4A0782C6, 0xCC93F068, 0x07CF23CD,
+ 0xF6999118, 0x3DC542BD, 0xBB513013, 0x700DE3B6,
+ 0x6D08D30E, 0xA65400AB, 0x20C07205, 0xEB9CA1A0,
+ 0x11E81EB4, 0xDAB4CD11, 0x5C20BFBF, 0x977C6C1A,
+ 0x8A795CA2, 0x41258F07, 0xC7B1FDA9, 0x0CED2E0C,
+ 0xFDBB9CD9, 0x36E74F7C, 0xB0733DD2, 0x7B2FEE77,
+ 0x662ADECF, 0xAD760D6A, 0x2BE27FC4, 0xE0BEAC61,
+ 0x123E1C2F, 0xD962CF8A, 0x5FF6BD24, 0x94AA6E81,
+ 0x89AF5E39, 0x42F38D9C, 0xC467FF32, 0x0F3B2C97,
+ 0xFE6D9E42, 0x35314DE7, 0xB3A53F49, 0x78F9ECEC,
+ 0x65FCDC54, 0xAEA00FF1, 0x28347D5F, 0xE368AEFA,
+ 0x16441B82, 0xDD18C827, 0x5B8CBA89, 0x90D0692C,
+ 0x8DD55994, 0x46898A31, 0xC01DF89F, 0x0B412B3A,
+ 0xFA1799EF, 0x314B4A4A, 0xB7DF38E4, 0x7C83EB41,
+ 0x6186DBF9, 0xAADA085C, 0x2C4E7AF2, 0xE712A957,
+ 0x15921919, 0xDECECABC, 0x585AB812, 0x93066BB7,
+ 0x8E035B0F, 0x455F88AA, 0xC3CBFA04, 0x089729A1,
+ 0xF9C19B74, 0x329D48D1, 0xB4093A7F, 0x7F55E9DA,
+ 0x6250D962, 0xA90C0AC7, 0x2F987869, 0xE4C4ABCC,
+ /* T8_6 */
+ 0x00000000, 0xA6770BB4, 0x979F1129, 0x31E81A9D,
+ 0xF44F2413, 0x52382FA7, 0x63D0353A, 0xC5A73E8E,
+ 0x33EF4E67, 0x959845D3, 0xA4705F4E, 0x020754FA,
+ 0xC7A06A74, 0x61D761C0, 0x503F7B5D, 0xF64870E9,
+ 0x67DE9CCE, 0xC1A9977A, 0xF0418DE7, 0x56368653,
+ 0x9391B8DD, 0x35E6B369, 0x040EA9F4, 0xA279A240,
+ 0x5431D2A9, 0xF246D91D, 0xC3AEC380, 0x65D9C834,
+ 0xA07EF6BA, 0x0609FD0E, 0x37E1E793, 0x9196EC27,
+ 0xCFBD399C, 0x69CA3228, 0x582228B5, 0xFE552301,
+ 0x3BF21D8F, 0x9D85163B, 0xAC6D0CA6, 0x0A1A0712,
+ 0xFC5277FB, 0x5A257C4F, 0x6BCD66D2, 0xCDBA6D66,
+ 0x081D53E8, 0xAE6A585C, 0x9F8242C1, 0x39F54975,
+ 0xA863A552, 0x0E14AEE6, 0x3FFCB47B, 0x998BBFCF,
+ 0x5C2C8141, 0xFA5B8AF5, 0xCBB39068, 0x6DC49BDC,
+ 0x9B8CEB35, 0x3DFBE081, 0x0C13FA1C, 0xAA64F1A8,
+ 0x6FC3CF26, 0xC9B4C492, 0xF85CDE0F, 0x5E2BD5BB,
+ 0x440B7579, 0xE27C7ECD, 0xD3946450, 0x75E36FE4,
+ 0xB044516A, 0x16335ADE, 0x27DB4043, 0x81AC4BF7,
+ 0x77E43B1E, 0xD19330AA, 0xE07B2A37, 0x460C2183,
+ 0x83AB1F0D, 0x25DC14B9, 0x14340E24, 0xB2430590,
+ 0x23D5E9B7, 0x85A2E203, 0xB44AF89E, 0x123DF32A,
+ 0xD79ACDA4, 0x71EDC610, 0x4005DC8D, 0xE672D739,
+ 0x103AA7D0, 0xB64DAC64, 0x87A5B6F9, 0x21D2BD4D,
+ 0xE47583C3, 0x42028877, 0x73EA92EA, 0xD59D995E,
+ 0x8BB64CE5, 0x2DC14751, 0x1C295DCC, 0xBA5E5678,
+ 0x7FF968F6, 0xD98E6342, 0xE86679DF, 0x4E11726B,
+ 0xB8590282, 0x1E2E0936, 0x2FC613AB, 0x89B1181F,
+ 0x4C162691, 0xEA612D25, 0xDB8937B8, 0x7DFE3C0C,
+ 0xEC68D02B, 0x4A1FDB9F, 0x7BF7C102, 0xDD80CAB6,
+ 0x1827F438, 0xBE50FF8C, 0x8FB8E511, 0x29CFEEA5,
+ 0xDF879E4C, 0x79F095F8, 0x48188F65, 0xEE6F84D1,
+ 0x2BC8BA5F, 0x8DBFB1EB, 0xBC57AB76, 0x1A20A0C2,
+ 0x8816EAF2, 0x2E61E146, 0x1F89FBDB, 0xB9FEF06F,
+ 0x7C59CEE1, 0xDA2EC555, 0xEBC6DFC8, 0x4DB1D47C,
+ 0xBBF9A495, 0x1D8EAF21, 0x2C66B5BC, 0x8A11BE08,
+ 0x4FB68086, 0xE9C18B32, 0xD82991AF, 0x7E5E9A1B,
+ 0xEFC8763C, 0x49BF7D88, 0x78576715, 0xDE206CA1,
+ 0x1B87522F, 0xBDF0599B, 0x8C184306, 0x2A6F48B2,
+ 0xDC27385B, 0x7A5033EF, 0x4BB82972, 0xEDCF22C6,
+ 0x28681C48, 0x8E1F17FC, 0xBFF70D61, 0x198006D5,
+ 0x47ABD36E, 0xE1DCD8DA, 0xD034C247, 0x7643C9F3,
+ 0xB3E4F77D, 0x1593FCC9, 0x247BE654, 0x820CEDE0,
+ 0x74449D09, 0xD23396BD, 0xE3DB8C20, 0x45AC8794,
+ 0x800BB91A, 0x267CB2AE, 0x1794A833, 0xB1E3A387,
+ 0x20754FA0, 0x86024414, 0xB7EA5E89, 0x119D553D,
+ 0xD43A6BB3, 0x724D6007, 0x43A57A9A, 0xE5D2712E,
+ 0x139A01C7, 0xB5ED0A73, 0x840510EE, 0x22721B5A,
+ 0xE7D525D4, 0x41A22E60, 0x704A34FD, 0xD63D3F49,
+ 0xCC1D9F8B, 0x6A6A943F, 0x5B828EA2, 0xFDF58516,
+ 0x3852BB98, 0x9E25B02C, 0xAFCDAAB1, 0x09BAA105,
+ 0xFFF2D1EC, 0x5985DA58, 0x686DC0C5, 0xCE1ACB71,
+ 0x0BBDF5FF, 0xADCAFE4B, 0x9C22E4D6, 0x3A55EF62,
+ 0xABC30345, 0x0DB408F1, 0x3C5C126C, 0x9A2B19D8,
+ 0x5F8C2756, 0xF9FB2CE2, 0xC813367F, 0x6E643DCB,
+ 0x982C4D22, 0x3E5B4696, 0x0FB35C0B, 0xA9C457BF,
+ 0x6C636931, 0xCA146285, 0xFBFC7818, 0x5D8B73AC,
+ 0x03A0A617, 0xA5D7ADA3, 0x943FB73E, 0x3248BC8A,
+ 0xF7EF8204, 0x519889B0, 0x6070932D, 0xC6079899,
+ 0x304FE870, 0x9638E3C4, 0xA7D0F959, 0x01A7F2ED,
+ 0xC400CC63, 0x6277C7D7, 0x539FDD4A, 0xF5E8D6FE,
+ 0x647E3AD9, 0xC209316D, 0xF3E12BF0, 0x55962044,
+ 0x90311ECA, 0x3646157E, 0x07AE0FE3, 0xA1D90457,
+ 0x579174BE, 0xF1E67F0A, 0xC00E6597, 0x66796E23,
+ 0xA3DE50AD, 0x05A95B19, 0x34414184, 0x92364A30,
+ /* T8_7 */
+ 0x00000000, 0xCCAA009E, 0x4225077D, 0x8E8F07E3,
+ 0x844A0EFA, 0x48E00E64, 0xC66F0987, 0x0AC50919,
+ 0xD3E51BB5, 0x1F4F1B2B, 0x91C01CC8, 0x5D6A1C56,
+ 0x57AF154F, 0x9B0515D1, 0x158A1232, 0xD92012AC,
+ 0x7CBB312B, 0xB01131B5, 0x3E9E3656, 0xF23436C8,
+ 0xF8F13FD1, 0x345B3F4F, 0xBAD438AC, 0x767E3832,
+ 0xAF5E2A9E, 0x63F42A00, 0xED7B2DE3, 0x21D12D7D,
+ 0x2B142464, 0xE7BE24FA, 0x69312319, 0xA59B2387,
+ 0xF9766256, 0x35DC62C8, 0xBB53652B, 0x77F965B5,
+ 0x7D3C6CAC, 0xB1966C32, 0x3F196BD1, 0xF3B36B4F,
+ 0x2A9379E3, 0xE639797D, 0x68B67E9E, 0xA41C7E00,
+ 0xAED97719, 0x62737787, 0xECFC7064, 0x205670FA,
+ 0x85CD537D, 0x496753E3, 0xC7E85400, 0x0B42549E,
+ 0x01875D87, 0xCD2D5D19, 0x43A25AFA, 0x8F085A64,
+ 0x562848C8, 0x9A824856, 0x140D4FB5, 0xD8A74F2B,
+ 0xD2624632, 0x1EC846AC, 0x9047414F, 0x5CED41D1,
+ 0x299DC2ED, 0xE537C273, 0x6BB8C590, 0xA712C50E,
+ 0xADD7CC17, 0x617DCC89, 0xEFF2CB6A, 0x2358CBF4,
+ 0xFA78D958, 0x36D2D9C6, 0xB85DDE25, 0x74F7DEBB,
+ 0x7E32D7A2, 0xB298D73C, 0x3C17D0DF, 0xF0BDD041,
+ 0x5526F3C6, 0x998CF358, 0x1703F4BB, 0xDBA9F425,
+ 0xD16CFD3C, 0x1DC6FDA2, 0x9349FA41, 0x5FE3FADF,
+ 0x86C3E873, 0x4A69E8ED, 0xC4E6EF0E, 0x084CEF90,
+ 0x0289E689, 0xCE23E617, 0x40ACE1F4, 0x8C06E16A,
+ 0xD0EBA0BB, 0x1C41A025, 0x92CEA7C6, 0x5E64A758,
+ 0x54A1AE41, 0x980BAEDF, 0x1684A93C, 0xDA2EA9A2,
+ 0x030EBB0E, 0xCFA4BB90, 0x412BBC73, 0x8D81BCED,
+ 0x8744B5F4, 0x4BEEB56A, 0xC561B289, 0x09CBB217,
+ 0xAC509190, 0x60FA910E, 0xEE7596ED, 0x22DF9673,
+ 0x281A9F6A, 0xE4B09FF4, 0x6A3F9817, 0xA6959889,
+ 0x7FB58A25, 0xB31F8ABB, 0x3D908D58, 0xF13A8DC6,
+ 0xFBFF84DF, 0x37558441, 0xB9DA83A2, 0x7570833C,
+ 0x533B85DA, 0x9F918544, 0x111E82A7, 0xDDB48239,
+ 0xD7718B20, 0x1BDB8BBE, 0x95548C5D, 0x59FE8CC3,
+ 0x80DE9E6F, 0x4C749EF1, 0xC2FB9912, 0x0E51998C,
+ 0x04949095, 0xC83E900B, 0x46B197E8, 0x8A1B9776,
+ 0x2F80B4F1, 0xE32AB46F, 0x6DA5B38C, 0xA10FB312,
+ 0xABCABA0B, 0x6760BA95, 0xE9EFBD76, 0x2545BDE8,
+ 0xFC65AF44, 0x30CFAFDA, 0xBE40A839, 0x72EAA8A7,
+ 0x782FA1BE, 0xB485A120, 0x3A0AA6C3, 0xF6A0A65D,
+ 0xAA4DE78C, 0x66E7E712, 0xE868E0F1, 0x24C2E06F,
+ 0x2E07E976, 0xE2ADE9E8, 0x6C22EE0B, 0xA088EE95,
+ 0x79A8FC39, 0xB502FCA7, 0x3B8DFB44, 0xF727FBDA,
+ 0xFDE2F2C3, 0x3148F25D, 0xBFC7F5BE, 0x736DF520,
+ 0xD6F6D6A7, 0x1A5CD639, 0x94D3D1DA, 0x5879D144,
+ 0x52BCD85D, 0x9E16D8C3, 0x1099DF20, 0xDC33DFBE,
+ 0x0513CD12, 0xC9B9CD8C, 0x4736CA6F, 0x8B9CCAF1,
+ 0x8159C3E8, 0x4DF3C376, 0xC37CC495, 0x0FD6C40B,
+ 0x7AA64737, 0xB60C47A9, 0x3883404A, 0xF42940D4,
+ 0xFEEC49CD, 0x32464953, 0xBCC94EB0, 0x70634E2E,
+ 0xA9435C82, 0x65E95C1C, 0xEB665BFF, 0x27CC5B61,
+ 0x2D095278, 0xE1A352E6, 0x6F2C5505, 0xA386559B,
+ 0x061D761C, 0xCAB77682, 0x44387161, 0x889271FF,
+ 0x825778E6, 0x4EFD7878, 0xC0727F9B, 0x0CD87F05,
+ 0xD5F86DA9, 0x19526D37, 0x97DD6AD4, 0x5B776A4A,
+ 0x51B26353, 0x9D1863CD, 0x1397642E, 0xDF3D64B0,
+ 0x83D02561, 0x4F7A25FF, 0xC1F5221C, 0x0D5F2282,
+ 0x079A2B9B, 0xCB302B05, 0x45BF2CE6, 0x89152C78,
+ 0x50353ED4, 0x9C9F3E4A, 0x121039A9, 0xDEBA3937,
+ 0xD47F302E, 0x18D530B0, 0x965A3753, 0x5AF037CD,
+ 0xFF6B144A, 0x33C114D4, 0xBD4E1337, 0x71E413A9,
+ 0x7B211AB0, 0xB78B1A2E, 0x39041DCD, 0xF5AE1D53,
+ 0x2C8E0FFF, 0xE0240F61, 0x6EAB0882, 0xA201081C,
+ 0xA8C40105, 0x646E019B, 0xEAE10678, 0x264B06E6
+ };
+}
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/PureJavaCrc32C.java b/ratis-common/src/main/java/org/apache/ratis/util/PureJavaCrc32C.java
new file mode 100644
index 0000000000..ce646db933
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/PureJavaCrc32C.java
@@ -0,0 +1,632 @@
+/**
+ * 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.
+ *
+ * Some portions of this file Copyright (c) 2004-2006 Intel Corportation
+ * and licensed under the BSD license.
+ */
+package org.apache.ratis.util;
+
+import java.util.zip.Checksum;
+
+/**
+ * A pure-java implementation of the CRC32 checksum that uses
+ * the CRC32-C polynomial, the same polynomial used by iSCSI
+ * and implemented on many Intel chipsets supporting SSE4.2.
+ */
+public class PureJavaCrc32C implements Checksum {
+
+ /** the current CRC value, bit-flipped */
+ private int crc;
+
+ /** Create a new PureJavaCrc32 object. */
+ public PureJavaCrc32C() {
+ reset();
+ }
+
+ @Override
+ public long getValue() {
+ long ret = crc;
+ return (~ret) & 0xffffffffL;
+ }
+
+ @Override
+ public void reset() {
+ crc = 0xffffffff;
+ }
+
+ @Override
+ public void update(byte[] b, int off, int len) {
+ int localCrc = crc;
+
+ while(len > 7) {
+ final int c0 =(b[off+0] ^ localCrc) & 0xff;
+ final int c1 =(b[off+1] ^ (localCrc >>>= 8)) & 0xff;
+ final int c2 =(b[off+2] ^ (localCrc >>>= 8)) & 0xff;
+ final int c3 =(b[off+3] ^ (localCrc >>>= 8)) & 0xff;
+ localCrc = (T[T8_7_start + c0] ^ T[T8_6_start + c1])
+ ^ (T[T8_5_start + c2] ^ T[T8_4_start + c3]);
+
+ final int c4 = b[off+4] & 0xff;
+ final int c5 = b[off+5] & 0xff;
+ final int c6 = b[off+6] & 0xff;
+ final int c7 = b[off+7] & 0xff;
+
+ localCrc ^= (T[T8_3_start + c4] ^ T[T8_2_start + c5])
+ ^ (T[T8_1_start + c6] ^ T[T8_0_start + c7]);
+
+ off += 8;
+ len -= 8;
+ }
+
+ /* loop unroll - duff's device style */
+ switch(len) {
+ case 7: localCrc = (localCrc >>> 8) ^ T[T8_0_start + ((localCrc ^ b[off++]) & 0xff)];
+ case 6: localCrc = (localCrc >>> 8) ^ T[T8_0_start + ((localCrc ^ b[off++]) & 0xff)];
+ case 5: localCrc = (localCrc >>> 8) ^ T[T8_0_start + ((localCrc ^ b[off++]) & 0xff)];
+ case 4: localCrc = (localCrc >>> 8) ^ T[T8_0_start + ((localCrc ^ b[off++]) & 0xff)];
+ case 3: localCrc = (localCrc >>> 8) ^ T[T8_0_start + ((localCrc ^ b[off++]) & 0xff)];
+ case 2: localCrc = (localCrc >>> 8) ^ T[T8_0_start + ((localCrc ^ b[off++]) & 0xff)];
+ case 1: localCrc = (localCrc >>> 8) ^ T[T8_0_start + ((localCrc ^ b[off++]) & 0xff)];
+ default:
+ /* nothing */
+ }
+
+ // Publish crc out to object
+ crc = localCrc;
+ }
+
+ @Override
+ final public void update(int b) {
+ crc = (crc >>> 8) ^ T[T8_0_start + ((crc ^ b) & 0xff)];
+ }
+
+ // CRC polynomial tables generated by:
+ // java -cp build/test/classes/:build/classes/ \
+ // org.apache.hadoop.util.TestPureJavaCrc32\$Table 82F63B78
+
+ private static final int T8_0_start = 0*256;
+ private static final int T8_1_start = 1*256;
+ private static final int T8_2_start = 2*256;
+ private static final int T8_3_start = 3*256;
+ private static final int T8_4_start = 4*256;
+ private static final int T8_5_start = 5*256;
+ private static final int T8_6_start = 6*256;
+ private static final int T8_7_start = 7*256;
+
+ private static final int[] T = new int[] {
+ /* T8_0 */
+ 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4,
+ 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
+ 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B,
+ 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
+ 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B,
+ 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
+ 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54,
+ 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
+ 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A,
+ 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
+ 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5,
+ 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
+ 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45,
+ 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
+ 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A,
+ 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
+ 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48,
+ 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
+ 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687,
+ 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
+ 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927,
+ 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
+ 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8,
+ 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
+ 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096,
+ 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
+ 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859,
+ 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
+ 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9,
+ 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
+ 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36,
+ 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
+ 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C,
+ 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
+ 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043,
+ 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
+ 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3,
+ 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
+ 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C,
+ 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
+ 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652,
+ 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
+ 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D,
+ 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
+ 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D,
+ 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
+ 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2,
+ 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
+ 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530,
+ 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
+ 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF,
+ 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
+ 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F,
+ 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
+ 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90,
+ 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
+ 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE,
+ 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
+ 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321,
+ 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
+ 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81,
+ 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
+ 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E,
+ 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351,
+ /* T8_1 */
+ 0x00000000, 0x13A29877, 0x274530EE, 0x34E7A899,
+ 0x4E8A61DC, 0x5D28F9AB, 0x69CF5132, 0x7A6DC945,
+ 0x9D14C3B8, 0x8EB65BCF, 0xBA51F356, 0xA9F36B21,
+ 0xD39EA264, 0xC03C3A13, 0xF4DB928A, 0xE7790AFD,
+ 0x3FC5F181, 0x2C6769F6, 0x1880C16F, 0x0B225918,
+ 0x714F905D, 0x62ED082A, 0x560AA0B3, 0x45A838C4,
+ 0xA2D13239, 0xB173AA4E, 0x859402D7, 0x96369AA0,
+ 0xEC5B53E5, 0xFFF9CB92, 0xCB1E630B, 0xD8BCFB7C,
+ 0x7F8BE302, 0x6C297B75, 0x58CED3EC, 0x4B6C4B9B,
+ 0x310182DE, 0x22A31AA9, 0x1644B230, 0x05E62A47,
+ 0xE29F20BA, 0xF13DB8CD, 0xC5DA1054, 0xD6788823,
+ 0xAC154166, 0xBFB7D911, 0x8B507188, 0x98F2E9FF,
+ 0x404E1283, 0x53EC8AF4, 0x670B226D, 0x74A9BA1A,
+ 0x0EC4735F, 0x1D66EB28, 0x298143B1, 0x3A23DBC6,
+ 0xDD5AD13B, 0xCEF8494C, 0xFA1FE1D5, 0xE9BD79A2,
+ 0x93D0B0E7, 0x80722890, 0xB4958009, 0xA737187E,
+ 0xFF17C604, 0xECB55E73, 0xD852F6EA, 0xCBF06E9D,
+ 0xB19DA7D8, 0xA23F3FAF, 0x96D89736, 0x857A0F41,
+ 0x620305BC, 0x71A19DCB, 0x45463552, 0x56E4AD25,
+ 0x2C896460, 0x3F2BFC17, 0x0BCC548E, 0x186ECCF9,
+ 0xC0D23785, 0xD370AFF2, 0xE797076B, 0xF4359F1C,
+ 0x8E585659, 0x9DFACE2E, 0xA91D66B7, 0xBABFFEC0,
+ 0x5DC6F43D, 0x4E646C4A, 0x7A83C4D3, 0x69215CA4,
+ 0x134C95E1, 0x00EE0D96, 0x3409A50F, 0x27AB3D78,
+ 0x809C2506, 0x933EBD71, 0xA7D915E8, 0xB47B8D9F,
+ 0xCE1644DA, 0xDDB4DCAD, 0xE9537434, 0xFAF1EC43,
+ 0x1D88E6BE, 0x0E2A7EC9, 0x3ACDD650, 0x296F4E27,
+ 0x53028762, 0x40A01F15, 0x7447B78C, 0x67E52FFB,
+ 0xBF59D487, 0xACFB4CF0, 0x981CE469, 0x8BBE7C1E,
+ 0xF1D3B55B, 0xE2712D2C, 0xD69685B5, 0xC5341DC2,
+ 0x224D173F, 0x31EF8F48, 0x050827D1, 0x16AABFA6,
+ 0x6CC776E3, 0x7F65EE94, 0x4B82460D, 0x5820DE7A,
+ 0xFBC3FAF9, 0xE861628E, 0xDC86CA17, 0xCF245260,
+ 0xB5499B25, 0xA6EB0352, 0x920CABCB, 0x81AE33BC,
+ 0x66D73941, 0x7575A136, 0x419209AF, 0x523091D8,
+ 0x285D589D, 0x3BFFC0EA, 0x0F186873, 0x1CBAF004,
+ 0xC4060B78, 0xD7A4930F, 0xE3433B96, 0xF0E1A3E1,
+ 0x8A8C6AA4, 0x992EF2D3, 0xADC95A4A, 0xBE6BC23D,
+ 0x5912C8C0, 0x4AB050B7, 0x7E57F82E, 0x6DF56059,
+ 0x1798A91C, 0x043A316B, 0x30DD99F2, 0x237F0185,
+ 0x844819FB, 0x97EA818C, 0xA30D2915, 0xB0AFB162,
+ 0xCAC27827, 0xD960E050, 0xED8748C9, 0xFE25D0BE,
+ 0x195CDA43, 0x0AFE4234, 0x3E19EAAD, 0x2DBB72DA,
+ 0x57D6BB9F, 0x447423E8, 0x70938B71, 0x63311306,
+ 0xBB8DE87A, 0xA82F700D, 0x9CC8D894, 0x8F6A40E3,
+ 0xF50789A6, 0xE6A511D1, 0xD242B948, 0xC1E0213F,
+ 0x26992BC2, 0x353BB3B5, 0x01DC1B2C, 0x127E835B,
+ 0x68134A1E, 0x7BB1D269, 0x4F567AF0, 0x5CF4E287,
+ 0x04D43CFD, 0x1776A48A, 0x23910C13, 0x30339464,
+ 0x4A5E5D21, 0x59FCC556, 0x6D1B6DCF, 0x7EB9F5B8,
+ 0x99C0FF45, 0x8A626732, 0xBE85CFAB, 0xAD2757DC,
+ 0xD74A9E99, 0xC4E806EE, 0xF00FAE77, 0xE3AD3600,
+ 0x3B11CD7C, 0x28B3550B, 0x1C54FD92, 0x0FF665E5,
+ 0x759BACA0, 0x663934D7, 0x52DE9C4E, 0x417C0439,
+ 0xA6050EC4, 0xB5A796B3, 0x81403E2A, 0x92E2A65D,
+ 0xE88F6F18, 0xFB2DF76F, 0xCFCA5FF6, 0xDC68C781,
+ 0x7B5FDFFF, 0x68FD4788, 0x5C1AEF11, 0x4FB87766,
+ 0x35D5BE23, 0x26772654, 0x12908ECD, 0x013216BA,
+ 0xE64B1C47, 0xF5E98430, 0xC10E2CA9, 0xD2ACB4DE,
+ 0xA8C17D9B, 0xBB63E5EC, 0x8F844D75, 0x9C26D502,
+ 0x449A2E7E, 0x5738B609, 0x63DF1E90, 0x707D86E7,
+ 0x0A104FA2, 0x19B2D7D5, 0x2D557F4C, 0x3EF7E73B,
+ 0xD98EEDC6, 0xCA2C75B1, 0xFECBDD28, 0xED69455F,
+ 0x97048C1A, 0x84A6146D, 0xB041BCF4, 0xA3E32483,
+ /* T8_2 */
+ 0x00000000, 0xA541927E, 0x4F6F520D, 0xEA2EC073,
+ 0x9EDEA41A, 0x3B9F3664, 0xD1B1F617, 0x74F06469,
+ 0x38513EC5, 0x9D10ACBB, 0x773E6CC8, 0xD27FFEB6,
+ 0xA68F9ADF, 0x03CE08A1, 0xE9E0C8D2, 0x4CA15AAC,
+ 0x70A27D8A, 0xD5E3EFF4, 0x3FCD2F87, 0x9A8CBDF9,
+ 0xEE7CD990, 0x4B3D4BEE, 0xA1138B9D, 0x045219E3,
+ 0x48F3434F, 0xEDB2D131, 0x079C1142, 0xA2DD833C,
+ 0xD62DE755, 0x736C752B, 0x9942B558, 0x3C032726,
+ 0xE144FB14, 0x4405696A, 0xAE2BA919, 0x0B6A3B67,
+ 0x7F9A5F0E, 0xDADBCD70, 0x30F50D03, 0x95B49F7D,
+ 0xD915C5D1, 0x7C5457AF, 0x967A97DC, 0x333B05A2,
+ 0x47CB61CB, 0xE28AF3B5, 0x08A433C6, 0xADE5A1B8,
+ 0x91E6869E, 0x34A714E0, 0xDE89D493, 0x7BC846ED,
+ 0x0F382284, 0xAA79B0FA, 0x40577089, 0xE516E2F7,
+ 0xA9B7B85B, 0x0CF62A25, 0xE6D8EA56, 0x43997828,
+ 0x37691C41, 0x92288E3F, 0x78064E4C, 0xDD47DC32,
+ 0xC76580D9, 0x622412A7, 0x880AD2D4, 0x2D4B40AA,
+ 0x59BB24C3, 0xFCFAB6BD, 0x16D476CE, 0xB395E4B0,
+ 0xFF34BE1C, 0x5A752C62, 0xB05BEC11, 0x151A7E6F,
+ 0x61EA1A06, 0xC4AB8878, 0x2E85480B, 0x8BC4DA75,
+ 0xB7C7FD53, 0x12866F2D, 0xF8A8AF5E, 0x5DE93D20,
+ 0x29195949, 0x8C58CB37, 0x66760B44, 0xC337993A,
+ 0x8F96C396, 0x2AD751E8, 0xC0F9919B, 0x65B803E5,
+ 0x1148678C, 0xB409F5F2, 0x5E273581, 0xFB66A7FF,
+ 0x26217BCD, 0x8360E9B3, 0x694E29C0, 0xCC0FBBBE,
+ 0xB8FFDFD7, 0x1DBE4DA9, 0xF7908DDA, 0x52D11FA4,
+ 0x1E704508, 0xBB31D776, 0x511F1705, 0xF45E857B,
+ 0x80AEE112, 0x25EF736C, 0xCFC1B31F, 0x6A802161,
+ 0x56830647, 0xF3C29439, 0x19EC544A, 0xBCADC634,
+ 0xC85DA25D, 0x6D1C3023, 0x8732F050, 0x2273622E,
+ 0x6ED23882, 0xCB93AAFC, 0x21BD6A8F, 0x84FCF8F1,
+ 0xF00C9C98, 0x554D0EE6, 0xBF63CE95, 0x1A225CEB,
+ 0x8B277743, 0x2E66E53D, 0xC448254E, 0x6109B730,
+ 0x15F9D359, 0xB0B84127, 0x5A968154, 0xFFD7132A,
+ 0xB3764986, 0x1637DBF8, 0xFC191B8B, 0x595889F5,
+ 0x2DA8ED9C, 0x88E97FE2, 0x62C7BF91, 0xC7862DEF,
+ 0xFB850AC9, 0x5EC498B7, 0xB4EA58C4, 0x11ABCABA,
+ 0x655BAED3, 0xC01A3CAD, 0x2A34FCDE, 0x8F756EA0,
+ 0xC3D4340C, 0x6695A672, 0x8CBB6601, 0x29FAF47F,
+ 0x5D0A9016, 0xF84B0268, 0x1265C21B, 0xB7245065,
+ 0x6A638C57, 0xCF221E29, 0x250CDE5A, 0x804D4C24,
+ 0xF4BD284D, 0x51FCBA33, 0xBBD27A40, 0x1E93E83E,
+ 0x5232B292, 0xF77320EC, 0x1D5DE09F, 0xB81C72E1,
+ 0xCCEC1688, 0x69AD84F6, 0x83834485, 0x26C2D6FB,
+ 0x1AC1F1DD, 0xBF8063A3, 0x55AEA3D0, 0xF0EF31AE,
+ 0x841F55C7, 0x215EC7B9, 0xCB7007CA, 0x6E3195B4,
+ 0x2290CF18, 0x87D15D66, 0x6DFF9D15, 0xC8BE0F6B,
+ 0xBC4E6B02, 0x190FF97C, 0xF321390F, 0x5660AB71,
+ 0x4C42F79A, 0xE90365E4, 0x032DA597, 0xA66C37E9,
+ 0xD29C5380, 0x77DDC1FE, 0x9DF3018D, 0x38B293F3,
+ 0x7413C95F, 0xD1525B21, 0x3B7C9B52, 0x9E3D092C,
+ 0xEACD6D45, 0x4F8CFF3B, 0xA5A23F48, 0x00E3AD36,
+ 0x3CE08A10, 0x99A1186E, 0x738FD81D, 0xD6CE4A63,
+ 0xA23E2E0A, 0x077FBC74, 0xED517C07, 0x4810EE79,
+ 0x04B1B4D5, 0xA1F026AB, 0x4BDEE6D8, 0xEE9F74A6,
+ 0x9A6F10CF, 0x3F2E82B1, 0xD50042C2, 0x7041D0BC,
+ 0xAD060C8E, 0x08479EF0, 0xE2695E83, 0x4728CCFD,
+ 0x33D8A894, 0x96993AEA, 0x7CB7FA99, 0xD9F668E7,
+ 0x9557324B, 0x3016A035, 0xDA386046, 0x7F79F238,
+ 0x0B899651, 0xAEC8042F, 0x44E6C45C, 0xE1A75622,
+ 0xDDA47104, 0x78E5E37A, 0x92CB2309, 0x378AB177,
+ 0x437AD51E, 0xE63B4760, 0x0C158713, 0xA954156D,
+ 0xE5F54FC1, 0x40B4DDBF, 0xAA9A1DCC, 0x0FDB8FB2,
+ 0x7B2BEBDB, 0xDE6A79A5, 0x3444B9D6, 0x91052BA8,
+ /* T8_3 */
+ 0x00000000, 0xDD45AAB8, 0xBF672381, 0x62228939,
+ 0x7B2231F3, 0xA6679B4B, 0xC4451272, 0x1900B8CA,
+ 0xF64463E6, 0x2B01C95E, 0x49234067, 0x9466EADF,
+ 0x8D665215, 0x5023F8AD, 0x32017194, 0xEF44DB2C,
+ 0xE964B13D, 0x34211B85, 0x560392BC, 0x8B463804,
+ 0x924680CE, 0x4F032A76, 0x2D21A34F, 0xF06409F7,
+ 0x1F20D2DB, 0xC2657863, 0xA047F15A, 0x7D025BE2,
+ 0x6402E328, 0xB9474990, 0xDB65C0A9, 0x06206A11,
+ 0xD725148B, 0x0A60BE33, 0x6842370A, 0xB5079DB2,
+ 0xAC072578, 0x71428FC0, 0x136006F9, 0xCE25AC41,
+ 0x2161776D, 0xFC24DDD5, 0x9E0654EC, 0x4343FE54,
+ 0x5A43469E, 0x8706EC26, 0xE524651F, 0x3861CFA7,
+ 0x3E41A5B6, 0xE3040F0E, 0x81268637, 0x5C632C8F,
+ 0x45639445, 0x98263EFD, 0xFA04B7C4, 0x27411D7C,
+ 0xC805C650, 0x15406CE8, 0x7762E5D1, 0xAA274F69,
+ 0xB327F7A3, 0x6E625D1B, 0x0C40D422, 0xD1057E9A,
+ 0xABA65FE7, 0x76E3F55F, 0x14C17C66, 0xC984D6DE,
+ 0xD0846E14, 0x0DC1C4AC, 0x6FE34D95, 0xB2A6E72D,
+ 0x5DE23C01, 0x80A796B9, 0xE2851F80, 0x3FC0B538,
+ 0x26C00DF2, 0xFB85A74A, 0x99A72E73, 0x44E284CB,
+ 0x42C2EEDA, 0x9F874462, 0xFDA5CD5B, 0x20E067E3,
+ 0x39E0DF29, 0xE4A57591, 0x8687FCA8, 0x5BC25610,
+ 0xB4868D3C, 0x69C32784, 0x0BE1AEBD, 0xD6A40405,
+ 0xCFA4BCCF, 0x12E11677, 0x70C39F4E, 0xAD8635F6,
+ 0x7C834B6C, 0xA1C6E1D4, 0xC3E468ED, 0x1EA1C255,
+ 0x07A17A9F, 0xDAE4D027, 0xB8C6591E, 0x6583F3A6,
+ 0x8AC7288A, 0x57828232, 0x35A00B0B, 0xE8E5A1B3,
+ 0xF1E51979, 0x2CA0B3C1, 0x4E823AF8, 0x93C79040,
+ 0x95E7FA51, 0x48A250E9, 0x2A80D9D0, 0xF7C57368,
+ 0xEEC5CBA2, 0x3380611A, 0x51A2E823, 0x8CE7429B,
+ 0x63A399B7, 0xBEE6330F, 0xDCC4BA36, 0x0181108E,
+ 0x1881A844, 0xC5C402FC, 0xA7E68BC5, 0x7AA3217D,
+ 0x52A0C93F, 0x8FE56387, 0xEDC7EABE, 0x30824006,
+ 0x2982F8CC, 0xF4C75274, 0x96E5DB4D, 0x4BA071F5,
+ 0xA4E4AAD9, 0x79A10061, 0x1B838958, 0xC6C623E0,
+ 0xDFC69B2A, 0x02833192, 0x60A1B8AB, 0xBDE41213,
+ 0xBBC47802, 0x6681D2BA, 0x04A35B83, 0xD9E6F13B,
+ 0xC0E649F1, 0x1DA3E349, 0x7F816A70, 0xA2C4C0C8,
+ 0x4D801BE4, 0x90C5B15C, 0xF2E73865, 0x2FA292DD,
+ 0x36A22A17, 0xEBE780AF, 0x89C50996, 0x5480A32E,
+ 0x8585DDB4, 0x58C0770C, 0x3AE2FE35, 0xE7A7548D,
+ 0xFEA7EC47, 0x23E246FF, 0x41C0CFC6, 0x9C85657E,
+ 0x73C1BE52, 0xAE8414EA, 0xCCA69DD3, 0x11E3376B,
+ 0x08E38FA1, 0xD5A62519, 0xB784AC20, 0x6AC10698,
+ 0x6CE16C89, 0xB1A4C631, 0xD3864F08, 0x0EC3E5B0,
+ 0x17C35D7A, 0xCA86F7C2, 0xA8A47EFB, 0x75E1D443,
+ 0x9AA50F6F, 0x47E0A5D7, 0x25C22CEE, 0xF8878656,
+ 0xE1873E9C, 0x3CC29424, 0x5EE01D1D, 0x83A5B7A5,
+ 0xF90696D8, 0x24433C60, 0x4661B559, 0x9B241FE1,
+ 0x8224A72B, 0x5F610D93, 0x3D4384AA, 0xE0062E12,
+ 0x0F42F53E, 0xD2075F86, 0xB025D6BF, 0x6D607C07,
+ 0x7460C4CD, 0xA9256E75, 0xCB07E74C, 0x16424DF4,
+ 0x106227E5, 0xCD278D5D, 0xAF050464, 0x7240AEDC,
+ 0x6B401616, 0xB605BCAE, 0xD4273597, 0x09629F2F,
+ 0xE6264403, 0x3B63EEBB, 0x59416782, 0x8404CD3A,
+ 0x9D0475F0, 0x4041DF48, 0x22635671, 0xFF26FCC9,
+ 0x2E238253, 0xF36628EB, 0x9144A1D2, 0x4C010B6A,
+ 0x5501B3A0, 0x88441918, 0xEA669021, 0x37233A99,
+ 0xD867E1B5, 0x05224B0D, 0x6700C234, 0xBA45688C,
+ 0xA345D046, 0x7E007AFE, 0x1C22F3C7, 0xC167597F,
+ 0xC747336E, 0x1A0299D6, 0x782010EF, 0xA565BA57,
+ 0xBC65029D, 0x6120A825, 0x0302211C, 0xDE478BA4,
+ 0x31035088, 0xEC46FA30, 0x8E647309, 0x5321D9B1,
+ 0x4A21617B, 0x9764CBC3, 0xF54642FA, 0x2803E842,
+ /* T8_4 */
+ 0x00000000, 0x38116FAC, 0x7022DF58, 0x4833B0F4,
+ 0xE045BEB0, 0xD854D11C, 0x906761E8, 0xA8760E44,
+ 0xC5670B91, 0xFD76643D, 0xB545D4C9, 0x8D54BB65,
+ 0x2522B521, 0x1D33DA8D, 0x55006A79, 0x6D1105D5,
+ 0x8F2261D3, 0xB7330E7F, 0xFF00BE8B, 0xC711D127,
+ 0x6F67DF63, 0x5776B0CF, 0x1F45003B, 0x27546F97,
+ 0x4A456A42, 0x725405EE, 0x3A67B51A, 0x0276DAB6,
+ 0xAA00D4F2, 0x9211BB5E, 0xDA220BAA, 0xE2336406,
+ 0x1BA8B557, 0x23B9DAFB, 0x6B8A6A0F, 0x539B05A3,
+ 0xFBED0BE7, 0xC3FC644B, 0x8BCFD4BF, 0xB3DEBB13,
+ 0xDECFBEC6, 0xE6DED16A, 0xAEED619E, 0x96FC0E32,
+ 0x3E8A0076, 0x069B6FDA, 0x4EA8DF2E, 0x76B9B082,
+ 0x948AD484, 0xAC9BBB28, 0xE4A80BDC, 0xDCB96470,
+ 0x74CF6A34, 0x4CDE0598, 0x04EDB56C, 0x3CFCDAC0,
+ 0x51EDDF15, 0x69FCB0B9, 0x21CF004D, 0x19DE6FE1,
+ 0xB1A861A5, 0x89B90E09, 0xC18ABEFD, 0xF99BD151,
+ 0x37516AAE, 0x0F400502, 0x4773B5F6, 0x7F62DA5A,
+ 0xD714D41E, 0xEF05BBB2, 0xA7360B46, 0x9F2764EA,
+ 0xF236613F, 0xCA270E93, 0x8214BE67, 0xBA05D1CB,
+ 0x1273DF8F, 0x2A62B023, 0x625100D7, 0x5A406F7B,
+ 0xB8730B7D, 0x806264D1, 0xC851D425, 0xF040BB89,
+ 0x5836B5CD, 0x6027DA61, 0x28146A95, 0x10050539,
+ 0x7D1400EC, 0x45056F40, 0x0D36DFB4, 0x3527B018,
+ 0x9D51BE5C, 0xA540D1F0, 0xED736104, 0xD5620EA8,
+ 0x2CF9DFF9, 0x14E8B055, 0x5CDB00A1, 0x64CA6F0D,
+ 0xCCBC6149, 0xF4AD0EE5, 0xBC9EBE11, 0x848FD1BD,
+ 0xE99ED468, 0xD18FBBC4, 0x99BC0B30, 0xA1AD649C,
+ 0x09DB6AD8, 0x31CA0574, 0x79F9B580, 0x41E8DA2C,
+ 0xA3DBBE2A, 0x9BCAD186, 0xD3F96172, 0xEBE80EDE,
+ 0x439E009A, 0x7B8F6F36, 0x33BCDFC2, 0x0BADB06E,
+ 0x66BCB5BB, 0x5EADDA17, 0x169E6AE3, 0x2E8F054F,
+ 0x86F90B0B, 0xBEE864A7, 0xF6DBD453, 0xCECABBFF,
+ 0x6EA2D55C, 0x56B3BAF0, 0x1E800A04, 0x269165A8,
+ 0x8EE76BEC, 0xB6F60440, 0xFEC5B4B4, 0xC6D4DB18,
+ 0xABC5DECD, 0x93D4B161, 0xDBE70195, 0xE3F66E39,
+ 0x4B80607D, 0x73910FD1, 0x3BA2BF25, 0x03B3D089,
+ 0xE180B48F, 0xD991DB23, 0x91A26BD7, 0xA9B3047B,
+ 0x01C50A3F, 0x39D46593, 0x71E7D567, 0x49F6BACB,
+ 0x24E7BF1E, 0x1CF6D0B2, 0x54C56046, 0x6CD40FEA,
+ 0xC4A201AE, 0xFCB36E02, 0xB480DEF6, 0x8C91B15A,
+ 0x750A600B, 0x4D1B0FA7, 0x0528BF53, 0x3D39D0FF,
+ 0x954FDEBB, 0xAD5EB117, 0xE56D01E3, 0xDD7C6E4F,
+ 0xB06D6B9A, 0x887C0436, 0xC04FB4C2, 0xF85EDB6E,
+ 0x5028D52A, 0x6839BA86, 0x200A0A72, 0x181B65DE,
+ 0xFA2801D8, 0xC2396E74, 0x8A0ADE80, 0xB21BB12C,
+ 0x1A6DBF68, 0x227CD0C4, 0x6A4F6030, 0x525E0F9C,
+ 0x3F4F0A49, 0x075E65E5, 0x4F6DD511, 0x777CBABD,
+ 0xDF0AB4F9, 0xE71BDB55, 0xAF286BA1, 0x9739040D,
+ 0x59F3BFF2, 0x61E2D05E, 0x29D160AA, 0x11C00F06,
+ 0xB9B60142, 0x81A76EEE, 0xC994DE1A, 0xF185B1B6,
+ 0x9C94B463, 0xA485DBCF, 0xECB66B3B, 0xD4A70497,
+ 0x7CD10AD3, 0x44C0657F, 0x0CF3D58B, 0x34E2BA27,
+ 0xD6D1DE21, 0xEEC0B18D, 0xA6F30179, 0x9EE26ED5,
+ 0x36946091, 0x0E850F3D, 0x46B6BFC9, 0x7EA7D065,
+ 0x13B6D5B0, 0x2BA7BA1C, 0x63940AE8, 0x5B856544,
+ 0xF3F36B00, 0xCBE204AC, 0x83D1B458, 0xBBC0DBF4,
+ 0x425B0AA5, 0x7A4A6509, 0x3279D5FD, 0x0A68BA51,
+ 0xA21EB415, 0x9A0FDBB9, 0xD23C6B4D, 0xEA2D04E1,
+ 0x873C0134, 0xBF2D6E98, 0xF71EDE6C, 0xCF0FB1C0,
+ 0x6779BF84, 0x5F68D028, 0x175B60DC, 0x2F4A0F70,
+ 0xCD796B76, 0xF56804DA, 0xBD5BB42E, 0x854ADB82,
+ 0x2D3CD5C6, 0x152DBA6A, 0x5D1E0A9E, 0x650F6532,
+ 0x081E60E7, 0x300F0F4B, 0x783CBFBF, 0x402DD013,
+ 0xE85BDE57, 0xD04AB1FB, 0x9879010F, 0xA0686EA3,
+ /* T8_5 */
+ 0x00000000, 0xEF306B19, 0xDB8CA0C3, 0x34BCCBDA,
+ 0xB2F53777, 0x5DC55C6E, 0x697997B4, 0x8649FCAD,
+ 0x6006181F, 0x8F367306, 0xBB8AB8DC, 0x54BAD3C5,
+ 0xD2F32F68, 0x3DC34471, 0x097F8FAB, 0xE64FE4B2,
+ 0xC00C303E, 0x2F3C5B27, 0x1B8090FD, 0xF4B0FBE4,
+ 0x72F90749, 0x9DC96C50, 0xA975A78A, 0x4645CC93,
+ 0xA00A2821, 0x4F3A4338, 0x7B8688E2, 0x94B6E3FB,
+ 0x12FF1F56, 0xFDCF744F, 0xC973BF95, 0x2643D48C,
+ 0x85F4168D, 0x6AC47D94, 0x5E78B64E, 0xB148DD57,
+ 0x370121FA, 0xD8314AE3, 0xEC8D8139, 0x03BDEA20,
+ 0xE5F20E92, 0x0AC2658B, 0x3E7EAE51, 0xD14EC548,
+ 0x570739E5, 0xB83752FC, 0x8C8B9926, 0x63BBF23F,
+ 0x45F826B3, 0xAAC84DAA, 0x9E748670, 0x7144ED69,
+ 0xF70D11C4, 0x183D7ADD, 0x2C81B107, 0xC3B1DA1E,
+ 0x25FE3EAC, 0xCACE55B5, 0xFE729E6F, 0x1142F576,
+ 0x970B09DB, 0x783B62C2, 0x4C87A918, 0xA3B7C201,
+ 0x0E045BEB, 0xE13430F2, 0xD588FB28, 0x3AB89031,
+ 0xBCF16C9C, 0x53C10785, 0x677DCC5F, 0x884DA746,
+ 0x6E0243F4, 0x813228ED, 0xB58EE337, 0x5ABE882E,
+ 0xDCF77483, 0x33C71F9A, 0x077BD440, 0xE84BBF59,
+ 0xCE086BD5, 0x213800CC, 0x1584CB16, 0xFAB4A00F,
+ 0x7CFD5CA2, 0x93CD37BB, 0xA771FC61, 0x48419778,
+ 0xAE0E73CA, 0x413E18D3, 0x7582D309, 0x9AB2B810,
+ 0x1CFB44BD, 0xF3CB2FA4, 0xC777E47E, 0x28478F67,
+ 0x8BF04D66, 0x64C0267F, 0x507CEDA5, 0xBF4C86BC,
+ 0x39057A11, 0xD6351108, 0xE289DAD2, 0x0DB9B1CB,
+ 0xEBF65579, 0x04C63E60, 0x307AF5BA, 0xDF4A9EA3,
+ 0x5903620E, 0xB6330917, 0x828FC2CD, 0x6DBFA9D4,
+ 0x4BFC7D58, 0xA4CC1641, 0x9070DD9B, 0x7F40B682,
+ 0xF9094A2F, 0x16392136, 0x2285EAEC, 0xCDB581F5,
+ 0x2BFA6547, 0xC4CA0E5E, 0xF076C584, 0x1F46AE9D,
+ 0x990F5230, 0x763F3929, 0x4283F2F3, 0xADB399EA,
+ 0x1C08B7D6, 0xF338DCCF, 0xC7841715, 0x28B47C0C,
+ 0xAEFD80A1, 0x41CDEBB8, 0x75712062, 0x9A414B7B,
+ 0x7C0EAFC9, 0x933EC4D0, 0xA7820F0A, 0x48B26413,
+ 0xCEFB98BE, 0x21CBF3A7, 0x1577387D, 0xFA475364,
+ 0xDC0487E8, 0x3334ECF1, 0x0788272B, 0xE8B84C32,
+ 0x6EF1B09F, 0x81C1DB86, 0xB57D105C, 0x5A4D7B45,
+ 0xBC029FF7, 0x5332F4EE, 0x678E3F34, 0x88BE542D,
+ 0x0EF7A880, 0xE1C7C399, 0xD57B0843, 0x3A4B635A,
+ 0x99FCA15B, 0x76CCCA42, 0x42700198, 0xAD406A81,
+ 0x2B09962C, 0xC439FD35, 0xF08536EF, 0x1FB55DF6,
+ 0xF9FAB944, 0x16CAD25D, 0x22761987, 0xCD46729E,
+ 0x4B0F8E33, 0xA43FE52A, 0x90832EF0, 0x7FB345E9,
+ 0x59F09165, 0xB6C0FA7C, 0x827C31A6, 0x6D4C5ABF,
+ 0xEB05A612, 0x0435CD0B, 0x308906D1, 0xDFB96DC8,
+ 0x39F6897A, 0xD6C6E263, 0xE27A29B9, 0x0D4A42A0,
+ 0x8B03BE0D, 0x6433D514, 0x508F1ECE, 0xBFBF75D7,
+ 0x120CEC3D, 0xFD3C8724, 0xC9804CFE, 0x26B027E7,
+ 0xA0F9DB4A, 0x4FC9B053, 0x7B757B89, 0x94451090,
+ 0x720AF422, 0x9D3A9F3B, 0xA98654E1, 0x46B63FF8,
+ 0xC0FFC355, 0x2FCFA84C, 0x1B736396, 0xF443088F,
+ 0xD200DC03, 0x3D30B71A, 0x098C7CC0, 0xE6BC17D9,
+ 0x60F5EB74, 0x8FC5806D, 0xBB794BB7, 0x544920AE,
+ 0xB206C41C, 0x5D36AF05, 0x698A64DF, 0x86BA0FC6,
+ 0x00F3F36B, 0xEFC39872, 0xDB7F53A8, 0x344F38B1,
+ 0x97F8FAB0, 0x78C891A9, 0x4C745A73, 0xA344316A,
+ 0x250DCDC7, 0xCA3DA6DE, 0xFE816D04, 0x11B1061D,
+ 0xF7FEE2AF, 0x18CE89B6, 0x2C72426C, 0xC3422975,
+ 0x450BD5D8, 0xAA3BBEC1, 0x9E87751B, 0x71B71E02,
+ 0x57F4CA8E, 0xB8C4A197, 0x8C786A4D, 0x63480154,
+ 0xE501FDF9, 0x0A3196E0, 0x3E8D5D3A, 0xD1BD3623,
+ 0x37F2D291, 0xD8C2B988, 0xEC7E7252, 0x034E194B,
+ 0x8507E5E6, 0x6A378EFF, 0x5E8B4525, 0xB1BB2E3C,
+ /* T8_6 */
+ 0x00000000, 0x68032CC8, 0xD0065990, 0xB8057558,
+ 0xA5E0C5D1, 0xCDE3E919, 0x75E69C41, 0x1DE5B089,
+ 0x4E2DFD53, 0x262ED19B, 0x9E2BA4C3, 0xF628880B,
+ 0xEBCD3882, 0x83CE144A, 0x3BCB6112, 0x53C84DDA,
+ 0x9C5BFAA6, 0xF458D66E, 0x4C5DA336, 0x245E8FFE,
+ 0x39BB3F77, 0x51B813BF, 0xE9BD66E7, 0x81BE4A2F,
+ 0xD27607F5, 0xBA752B3D, 0x02705E65, 0x6A7372AD,
+ 0x7796C224, 0x1F95EEEC, 0xA7909BB4, 0xCF93B77C,
+ 0x3D5B83BD, 0x5558AF75, 0xED5DDA2D, 0x855EF6E5,
+ 0x98BB466C, 0xF0B86AA4, 0x48BD1FFC, 0x20BE3334,
+ 0x73767EEE, 0x1B755226, 0xA370277E, 0xCB730BB6,
+ 0xD696BB3F, 0xBE9597F7, 0x0690E2AF, 0x6E93CE67,
+ 0xA100791B, 0xC90355D3, 0x7106208B, 0x19050C43,
+ 0x04E0BCCA, 0x6CE39002, 0xD4E6E55A, 0xBCE5C992,
+ 0xEF2D8448, 0x872EA880, 0x3F2BDDD8, 0x5728F110,
+ 0x4ACD4199, 0x22CE6D51, 0x9ACB1809, 0xF2C834C1,
+ 0x7AB7077A, 0x12B42BB2, 0xAAB15EEA, 0xC2B27222,
+ 0xDF57C2AB, 0xB754EE63, 0x0F519B3B, 0x6752B7F3,
+ 0x349AFA29, 0x5C99D6E1, 0xE49CA3B9, 0x8C9F8F71,
+ 0x917A3FF8, 0xF9791330, 0x417C6668, 0x297F4AA0,
+ 0xE6ECFDDC, 0x8EEFD114, 0x36EAA44C, 0x5EE98884,
+ 0x430C380D, 0x2B0F14C5, 0x930A619D, 0xFB094D55,
+ 0xA8C1008F, 0xC0C22C47, 0x78C7591F, 0x10C475D7,
+ 0x0D21C55E, 0x6522E996, 0xDD279CCE, 0xB524B006,
+ 0x47EC84C7, 0x2FEFA80F, 0x97EADD57, 0xFFE9F19F,
+ 0xE20C4116, 0x8A0F6DDE, 0x320A1886, 0x5A09344E,
+ 0x09C17994, 0x61C2555C, 0xD9C72004, 0xB1C40CCC,
+ 0xAC21BC45, 0xC422908D, 0x7C27E5D5, 0x1424C91D,
+ 0xDBB77E61, 0xB3B452A9, 0x0BB127F1, 0x63B20B39,
+ 0x7E57BBB0, 0x16549778, 0xAE51E220, 0xC652CEE8,
+ 0x959A8332, 0xFD99AFFA, 0x459CDAA2, 0x2D9FF66A,
+ 0x307A46E3, 0x58796A2B, 0xE07C1F73, 0x887F33BB,
+ 0xF56E0EF4, 0x9D6D223C, 0x25685764, 0x4D6B7BAC,
+ 0x508ECB25, 0x388DE7ED, 0x808892B5, 0xE88BBE7D,
+ 0xBB43F3A7, 0xD340DF6F, 0x6B45AA37, 0x034686FF,
+ 0x1EA33676, 0x76A01ABE, 0xCEA56FE6, 0xA6A6432E,
+ 0x6935F452, 0x0136D89A, 0xB933ADC2, 0xD130810A,
+ 0xCCD53183, 0xA4D61D4B, 0x1CD36813, 0x74D044DB,
+ 0x27180901, 0x4F1B25C9, 0xF71E5091, 0x9F1D7C59,
+ 0x82F8CCD0, 0xEAFBE018, 0x52FE9540, 0x3AFDB988,
+ 0xC8358D49, 0xA036A181, 0x1833D4D9, 0x7030F811,
+ 0x6DD54898, 0x05D66450, 0xBDD31108, 0xD5D03DC0,
+ 0x8618701A, 0xEE1B5CD2, 0x561E298A, 0x3E1D0542,
+ 0x23F8B5CB, 0x4BFB9903, 0xF3FEEC5B, 0x9BFDC093,
+ 0x546E77EF, 0x3C6D5B27, 0x84682E7F, 0xEC6B02B7,
+ 0xF18EB23E, 0x998D9EF6, 0x2188EBAE, 0x498BC766,
+ 0x1A438ABC, 0x7240A674, 0xCA45D32C, 0xA246FFE4,
+ 0xBFA34F6D, 0xD7A063A5, 0x6FA516FD, 0x07A63A35,
+ 0x8FD9098E, 0xE7DA2546, 0x5FDF501E, 0x37DC7CD6,
+ 0x2A39CC5F, 0x423AE097, 0xFA3F95CF, 0x923CB907,
+ 0xC1F4F4DD, 0xA9F7D815, 0x11F2AD4D, 0x79F18185,
+ 0x6414310C, 0x0C171DC4, 0xB412689C, 0xDC114454,
+ 0x1382F328, 0x7B81DFE0, 0xC384AAB8, 0xAB878670,
+ 0xB66236F9, 0xDE611A31, 0x66646F69, 0x0E6743A1,
+ 0x5DAF0E7B, 0x35AC22B3, 0x8DA957EB, 0xE5AA7B23,
+ 0xF84FCBAA, 0x904CE762, 0x2849923A, 0x404ABEF2,
+ 0xB2828A33, 0xDA81A6FB, 0x6284D3A3, 0x0A87FF6B,
+ 0x17624FE2, 0x7F61632A, 0xC7641672, 0xAF673ABA,
+ 0xFCAF7760, 0x94AC5BA8, 0x2CA92EF0, 0x44AA0238,
+ 0x594FB2B1, 0x314C9E79, 0x8949EB21, 0xE14AC7E9,
+ 0x2ED97095, 0x46DA5C5D, 0xFEDF2905, 0x96DC05CD,
+ 0x8B39B544, 0xE33A998C, 0x5B3FECD4, 0x333CC01C,
+ 0x60F48DC6, 0x08F7A10E, 0xB0F2D456, 0xD8F1F89E,
+ 0xC5144817, 0xAD1764DF, 0x15121187, 0x7D113D4F,
+ /* T8_7 */
+ 0x00000000, 0x493C7D27, 0x9278FA4E, 0xDB448769,
+ 0x211D826D, 0x6821FF4A, 0xB3657823, 0xFA590504,
+ 0x423B04DA, 0x0B0779FD, 0xD043FE94, 0x997F83B3,
+ 0x632686B7, 0x2A1AFB90, 0xF15E7CF9, 0xB86201DE,
+ 0x847609B4, 0xCD4A7493, 0x160EF3FA, 0x5F328EDD,
+ 0xA56B8BD9, 0xEC57F6FE, 0x37137197, 0x7E2F0CB0,
+ 0xC64D0D6E, 0x8F717049, 0x5435F720, 0x1D098A07,
+ 0xE7508F03, 0xAE6CF224, 0x7528754D, 0x3C14086A,
+ 0x0D006599, 0x443C18BE, 0x9F789FD7, 0xD644E2F0,
+ 0x2C1DE7F4, 0x65219AD3, 0xBE651DBA, 0xF759609D,
+ 0x4F3B6143, 0x06071C64, 0xDD439B0D, 0x947FE62A,
+ 0x6E26E32E, 0x271A9E09, 0xFC5E1960, 0xB5626447,
+ 0x89766C2D, 0xC04A110A, 0x1B0E9663, 0x5232EB44,
+ 0xA86BEE40, 0xE1579367, 0x3A13140E, 0x732F6929,
+ 0xCB4D68F7, 0x827115D0, 0x593592B9, 0x1009EF9E,
+ 0xEA50EA9A, 0xA36C97BD, 0x782810D4, 0x31146DF3,
+ 0x1A00CB32, 0x533CB615, 0x8878317C, 0xC1444C5B,
+ 0x3B1D495F, 0x72213478, 0xA965B311, 0xE059CE36,
+ 0x583BCFE8, 0x1107B2CF, 0xCA4335A6, 0x837F4881,
+ 0x79264D85, 0x301A30A2, 0xEB5EB7CB, 0xA262CAEC,
+ 0x9E76C286, 0xD74ABFA1, 0x0C0E38C8, 0x453245EF,
+ 0xBF6B40EB, 0xF6573DCC, 0x2D13BAA5, 0x642FC782,
+ 0xDC4DC65C, 0x9571BB7B, 0x4E353C12, 0x07094135,
+ 0xFD504431, 0xB46C3916, 0x6F28BE7F, 0x2614C358,
+ 0x1700AEAB, 0x5E3CD38C, 0x857854E5, 0xCC4429C2,
+ 0x361D2CC6, 0x7F2151E1, 0xA465D688, 0xED59ABAF,
+ 0x553BAA71, 0x1C07D756, 0xC743503F, 0x8E7F2D18,
+ 0x7426281C, 0x3D1A553B, 0xE65ED252, 0xAF62AF75,
+ 0x9376A71F, 0xDA4ADA38, 0x010E5D51, 0x48322076,
+ 0xB26B2572, 0xFB575855, 0x2013DF3C, 0x692FA21B,
+ 0xD14DA3C5, 0x9871DEE2, 0x4335598B, 0x0A0924AC,
+ 0xF05021A8, 0xB96C5C8F, 0x6228DBE6, 0x2B14A6C1,
+ 0x34019664, 0x7D3DEB43, 0xA6796C2A, 0xEF45110D,
+ 0x151C1409, 0x5C20692E, 0x8764EE47, 0xCE589360,
+ 0x763A92BE, 0x3F06EF99, 0xE44268F0, 0xAD7E15D7,
+ 0x572710D3, 0x1E1B6DF4, 0xC55FEA9D, 0x8C6397BA,
+ 0xB0779FD0, 0xF94BE2F7, 0x220F659E, 0x6B3318B9,
+ 0x916A1DBD, 0xD856609A, 0x0312E7F3, 0x4A2E9AD4,
+ 0xF24C9B0A, 0xBB70E62D, 0x60346144, 0x29081C63,
+ 0xD3511967, 0x9A6D6440, 0x4129E329, 0x08159E0E,
+ 0x3901F3FD, 0x703D8EDA, 0xAB7909B3, 0xE2457494,
+ 0x181C7190, 0x51200CB7, 0x8A648BDE, 0xC358F6F9,
+ 0x7B3AF727, 0x32068A00, 0xE9420D69, 0xA07E704E,
+ 0x5A27754A, 0x131B086D, 0xC85F8F04, 0x8163F223,
+ 0xBD77FA49, 0xF44B876E, 0x2F0F0007, 0x66337D20,
+ 0x9C6A7824, 0xD5560503, 0x0E12826A, 0x472EFF4D,
+ 0xFF4CFE93, 0xB67083B4, 0x6D3404DD, 0x240879FA,
+ 0xDE517CFE, 0x976D01D9, 0x4C2986B0, 0x0515FB97,
+ 0x2E015D56, 0x673D2071, 0xBC79A718, 0xF545DA3F,
+ 0x0F1CDF3B, 0x4620A21C, 0x9D642575, 0xD4585852,
+ 0x6C3A598C, 0x250624AB, 0xFE42A3C2, 0xB77EDEE5,
+ 0x4D27DBE1, 0x041BA6C6, 0xDF5F21AF, 0x96635C88,
+ 0xAA7754E2, 0xE34B29C5, 0x380FAEAC, 0x7133D38B,
+ 0x8B6AD68F, 0xC256ABA8, 0x19122CC1, 0x502E51E6,
+ 0xE84C5038, 0xA1702D1F, 0x7A34AA76, 0x3308D751,
+ 0xC951D255, 0x806DAF72, 0x5B29281B, 0x1215553C,
+ 0x230138CF, 0x6A3D45E8, 0xB179C281, 0xF845BFA6,
+ 0x021CBAA2, 0x4B20C785, 0x906440EC, 0xD9583DCB,
+ 0x613A3C15, 0x28064132, 0xF342C65B, 0xBA7EBB7C,
+ 0x4027BE78, 0x091BC35F, 0xD25F4436, 0x9B633911,
+ 0xA777317B, 0xEE4B4C5C, 0x350FCB35, 0x7C33B612,
+ 0x866AB316, 0xCF56CE31, 0x14124958, 0x5D2E347F,
+ 0xE54C35A1, 0xAC704886, 0x7734CFEF, 0x3E08B2C8,
+ 0xC451B7CC, 0x8D6DCAEB, 0x56294D82, 0x1F1530A5
+ };
+}
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/RaftUtils.java b/ratis-common/src/main/java/org/apache/ratis/util/RaftUtils.java
new file mode 100644
index 0000000000..8621cefd3f
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/RaftUtils.java
@@ -0,0 +1,240 @@
+/**
+ * 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.ratis.util;
+
+import com.google.common.base.Preconditions;
+import org.apache.log4j.Level;
+import org.apache.log4j.LogManager;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.lang.reflect.Constructor;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ThreadLocalRandom;
+
+public abstract class RaftUtils {
+ public static final Logger LOG = LoggerFactory.getLogger(RaftUtils.class);
+ private static final Class[] EMPTY_CLASS_ARRAY = {};
+
+ // OSType detection
+ public enum OSType {
+ OS_TYPE_LINUX,
+ OS_TYPE_WIN,
+ OS_TYPE_SOLARIS,
+ OS_TYPE_MAC,
+ OS_TYPE_FREEBSD,
+ OS_TYPE_OTHER
+ }
+
+ /**
+ * Get the type of the operating system, as determined from parsing
+ * the os.name property.
+ */
+ private static final OSType osType = getOSType();
+
+ private static OSType getOSType() {
+ String osName = System.getProperty("os.name");
+ if (osName.startsWith("Windows")) {
+ return OSType.OS_TYPE_WIN;
+ } else if (osName.contains("SunOS") || osName.contains("Solaris")) {
+ return OSType.OS_TYPE_SOLARIS;
+ } else if (osName.contains("Mac")) {
+ return OSType.OS_TYPE_MAC;
+ } else if (osName.contains("FreeBSD")) {
+ return OSType.OS_TYPE_FREEBSD;
+ } else if (osName.startsWith("Linux")) {
+ return OSType.OS_TYPE_LINUX;
+ } else {
+ // Some other form of Unix
+ return OSType.OS_TYPE_OTHER;
+ }
+ }
+
+ // Helper static vars for each platform
+ public static final boolean WINDOWS = (osType == OSType.OS_TYPE_WIN);
+ public static final boolean SOLARIS = (osType == OSType.OS_TYPE_SOLARIS);
+ public static final boolean MAC = (osType == OSType.OS_TYPE_MAC);
+ public static final boolean FREEBSD = (osType == OSType.OS_TYPE_FREEBSD);
+ public static final boolean LINUX = (osType == OSType.OS_TYPE_LINUX);
+ public static final boolean OTHER = (osType == OSType.OS_TYPE_OTHER);
+
+ public static final boolean PPC_64
+ = System.getProperties().getProperty("os.arch").contains("ppc64");
+
+ /**
+ * Cache of constructors for each class. Pins the classes so they
+ * can't be garbage collected until ReflectionUtils can be collected.
+ */
+ private static final Map, Constructor> CONSTRUCTOR_CACHE =
+ new ConcurrentHashMap<>();
+
+ public static InterruptedIOException toInterruptedIOException(
+ String message, InterruptedException e) {
+ final InterruptedIOException iioe = new InterruptedIOException(message);
+ iioe.initCause(e);
+ return iioe;
+ }
+
+ public static IOException asIOException(Throwable t) {
+ return t instanceof IOException? (IOException)t : new IOException(t);
+ }
+
+ public static IOException toIOException(ExecutionException e) {
+ final Throwable cause = e.getCause();
+ return cause != null? asIOException(cause): new IOException(e);
+ }
+
+ /** Is the given object an instance of one of the given classes? */
+ public static boolean isInstance(Object obj, Class... classes) {
+ for(Class c : classes) {
+ if (c.isInstance(obj)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Create an object for the given class and initialize it from conf
+ *
+ * @param theClass class of which an object is created
+ * @return a new object
+ */
+ @SuppressWarnings("unchecked")
+ public static T newInstance(Class theClass, Object... initArgs) {
+ T result;
+ try {
+ Constructor meth = (Constructor) CONSTRUCTOR_CACHE.get(theClass);
+ if (meth == null) {
+ meth = theClass.getDeclaredConstructor(EMPTY_CLASS_ARRAY);
+ meth.setAccessible(true);
+ CONSTRUCTOR_CACHE.put(theClass, meth);
+ }
+ result = meth.newInstance(initArgs);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ return result;
+ }
+
+ public static int getRandomBetween(int min, int max) {
+ Preconditions.checkArgument(max > min);
+ return ThreadLocalRandom.current().nextInt(max -min) + min;
+ }
+
+ public static void setLogLevel(Logger logger, Level level) {
+ LogManager.getLogger(logger.getName()).setLevel(level);
+ }
+
+
+ public static void readFully(InputStream in, int buffSize) throws IOException {
+ final byte buf[] = new byte[buffSize];
+ for(int bytesRead = in.read(buf); bytesRead >= 0; ) {
+ bytesRead = in.read(buf);
+ }
+ }
+
+ /**
+ * Reads len bytes in a loop.
+ *
+ * @param in InputStream to read from
+ * @param buf The buffer to fill
+ * @param off offset from the buffer
+ * @param len the length of bytes to read
+ * @throws IOException if it could not read requested number of bytes
+ * for any reason (including EOF)
+ */
+ public static void readFully(InputStream in, byte[] buf, int off, int len)
+ throws IOException {
+ for(int toRead = len; toRead > 0; ) {
+ final int ret = in.read(buf, off, toRead);
+ if (ret < 0) {
+ throw new IOException( "Premature EOF from inputStream");
+ }
+ toRead -= ret;
+ off += ret;
+ }
+ }
+
+ /**
+ * Write a ByteBuffer to a FileChannel at a given offset,
+ * handling short writes.
+ *
+ * @param fc The FileChannel to write to
+ * @param buf The input buffer
+ * @param offset The offset in the file to start writing at
+ * @throws IOException On I/O error
+ */
+ public static void writeFully(FileChannel fc, ByteBuffer buf, long offset)
+ throws IOException {
+ do {
+ offset += fc.write(buf, offset);
+ } while (buf.remaining() > 0);
+ }
+
+ /**
+ * Similar to readFully(). Skips bytes in a loop.
+ * @param in The InputStream to skip bytes from
+ * @param len number of bytes to skip.
+ * @throws IOException if it could not skip requested number of bytes
+ * for any reason (including EOF)
+ */
+ public static void skipFully(InputStream in, long len) throws IOException {
+ long amt = len;
+ while (amt > 0) {
+ long ret = in.skip(amt);
+ if (ret == 0) {
+ // skip may return 0 even if we're not at EOF. Luckily, we can
+ // use the read() method to figure out if we're at the end.
+ int b = in.read();
+ if (b == -1) {
+ throw new EOFException( "Premature EOF from inputStream after " +
+ "skipping " + (len - amt) + " byte(s).");
+ }
+ ret = 1;
+ }
+ amt -= ret;
+ }
+ }
+
+ /**
+ * Close the Closeable objects and ignore any {@link Throwable} or
+ * null pointers. Must only be used for cleanup in exception handlers.
+ *
+ * @param log the log to record problems to at debug level. Can be null.
+ * @param closeables the objects to close
+ */
+ public static void cleanup(Logger log, Closeable... closeables) {
+ for (Closeable c : closeables) {
+ if (c != null) {
+ try {
+ c.close();
+ } catch(Throwable e) {
+ if (log != null && log.isDebugEnabled()) {
+ log.debug("Exception in closing " + c, e);
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/StringUtils.java b/ratis-common/src/main/java/org/apache/ratis/util/StringUtils.java
new file mode 100644
index 0000000000..511ebbed64
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/StringUtils.java
@@ -0,0 +1,108 @@
+/**
+ * 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.ratis.util;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Interner;
+import com.google.common.collect.Interners;
+
+import java.util.Iterator;
+import java.util.Locale;
+
+public class StringUtils {
+ public static final String[] EMPTY_STRING_ARRAY = {};
+
+ /** Retains a weak reference to each string instance it has interned. */
+ private static final Interner WEAK_INTERNER = Interners.newWeakInterner();
+
+ /**
+ * Interns and returns a reference to the representative instance
+ * for any of a collection of string instances that are equal to each other.
+ * Retains weak reference to the instance,
+ * and so does not prevent it from being garbage-collected.
+ *
+ * @param sample string instance to be interned
+ * @return weak reference to interned string instance
+ */
+ public static String weakIntern(String sample) {
+ return sample == null? null: WEAK_INTERNER.intern(sample);
+ }
+
+ /**
+ * Splits the given comma separated {@link String}.
+ * Each split value is trimmed.
+ *
+ * @param s a comma separated {@link String}, or possibly null.
+ * @return the split strings, or an empty array if the given string is null.
+ */
+ public static String[] getTrimmedStrings(String s) {
+ return s == null? EMPTY_STRING_ARRAY
+ : (s = s.trim()).isEmpty()? EMPTY_STRING_ARRAY
+ : s.split("\\s*,\\s*");
+ }
+
+ /** The same as String.format(Locale.ENGLISH, format, objects). */
+ public static String format(final String format, final Object... objects) {
+ return String.format(Locale.ENGLISH, format, objects);
+ }
+
+ public static String bytes2HexString(byte[] bytes) {
+ Preconditions.checkNotNull(bytes);
+
+ final StringBuilder s = new StringBuilder(2 * bytes.length);
+ for(byte b : bytes) {
+ s.append(format("%02x", b));
+ }
+ return s.toString();
+ }
+
+ public static boolean string2boolean(String s, boolean defaultValue) {
+ if (s == null || s.isEmpty()) {
+ return defaultValue;
+ }
+
+ if ("true".equalsIgnoreCase(s)) {
+ return true;
+ } else if ("false".equalsIgnoreCase(s)) {
+ return false;
+ } else {
+ return defaultValue;
+ }
+ }
+
+ /**
+ * @return the next string in the iteration right after the given string;
+ * if the given string is not in the iteration, return the first string.
+ */
+ public static String next(final String given, final Iterable iteration) {
+ Preconditions.checkNotNull(given);
+ Preconditions.checkNotNull(iteration);
+ final Iterator i = iteration.iterator();
+ Preconditions.checkArgument(i.hasNext());
+
+ final String first = i.next();
+ for(String current = first; i.hasNext(); ) {
+ final String next = i.next();
+ if (given.equals(current)) {
+ return next;
+ }
+ current = next;
+ }
+ return first;
+ }
+}
diff --git a/ratis-common/src/main/java/org/apache/ratis/util/Timestamp.java b/ratis-common/src/main/java/org/apache/ratis/util/Timestamp.java
new file mode 100644
index 0000000000..96e2a5755b
--- /dev/null
+++ b/ratis-common/src/main/java/org/apache/ratis/util/Timestamp.java
@@ -0,0 +1,84 @@
+/**
+ * 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.ratis.util;
+
+/**
+ * Use {@link System#nanoTime()} as timestamps.
+ *
+ * This class takes care the possibility of numerical overflow.
+ *
+ * The objects of this class are immutable.
+ */
+public class Timestamp implements Comparable {
+ private static final long NANOSECONDS_PER_MILLISECOND = 1000000;
+
+ private static final long START_TIME = System.nanoTime();
+
+ /** @return the latest timestamp. */
+ public static Timestamp latest(Timestamp a, Timestamp b) {
+ return a.compareTo(b) > 0? a: b;
+ }
+
+ private final long nanos;
+
+ private Timestamp(long nanos) {
+ this.nanos = nanos;
+ }
+
+ /** Construct a timestamp with the current time. */
+ public Timestamp() {
+ this(System.nanoTime());
+ }
+
+ /**
+ * @param milliseconds the time period to be added.
+ * @return a new {@link Timestamp} whose value is calculated
+ * by adding the given milliseconds to this timestamp.
+ */
+ public Timestamp addTimeMs(long milliseconds) {
+ return new Timestamp(nanos + milliseconds * NANOSECONDS_PER_MILLISECOND);
+ }
+
+ /**
+ * @return the elapsed time in milliseconds.
+ * If the timestamp is a future time,
+ * this method returns a negative value.
+ */
+ public long elapsedTimeMs() {
+ final long d = System.nanoTime() - nanos;
+ return d / NANOSECONDS_PER_MILLISECOND;
+ }
+
+ /**
+ * Compare two timestamps, t0 (this) and t1 (that).
+ * This method uses {@code t0 - t1 < 0}, not {@code t0 < t1},
+ * in order to take care the possibility of numerical overflow.
+ *
+ * @see System#nanoTime()
+ */
+ @Override
+ public int compareTo(Timestamp that) {
+ final long d = this.nanos - that.nanos;
+ return d > 0? 1: d == 0? 0: -1;
+ }
+
+ @Override
+ public String toString() {
+ return (nanos - START_TIME)/NANOSECONDS_PER_MILLISECOND + "ms";
+ }
+}
diff --git a/ratis-common/src/main/native/src/exception.c b/ratis-common/src/main/native/src/exception.c
new file mode 100644
index 0000000000..fc072e8002
--- /dev/null
+++ b/ratis-common/src/main/native/src/exception.c
@@ -0,0 +1,124 @@
+/**
+ * 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.
+ */
+
+#include "exception.h"
+
+#include
+#include
+#include
+#include
+
+jthrowable newExceptionV(JNIEnv* env, const char *name,
+ const char *fmt, va_list ap)
+{
+ int need;
+ char buf[1], *msg = NULL;
+ va_list ap2;
+ jstring jstr = NULL;
+ jthrowable jthr;
+ jclass clazz;
+ jmethodID excCtor;
+
+ va_copy(ap2, ap);
+ clazz = (*env)->FindClass(env, name);
+ if (!clazz) {
+ jthr = (*env)->ExceptionOccurred(env);
+ (*env)->ExceptionClear(env);
+ goto done;
+ }
+ excCtor = (*env)->GetMethodID(env,
+ clazz, "", "(Ljava/lang/String;)V");
+ if (!excCtor) {
+ jthr = (*env)->ExceptionOccurred(env);
+ (*env)->ExceptionClear(env);
+ goto done;
+ }
+ need = vsnprintf(buf, sizeof(buf), fmt, ap);
+ if (need < 0) {
+ fmt = "vsnprintf error";
+ need = strlen(fmt);
+ }
+ msg = malloc(need + 1);
+ vsnprintf(msg, need + 1, fmt, ap2);
+ jstr = (*env)->NewStringUTF(env, msg);
+ if (!jstr) {
+ jthr = (*env)->ExceptionOccurred(env);
+ (*env)->ExceptionClear(env);
+ goto done;
+ }
+ jthr = (*env)->NewObject(env, clazz, excCtor, jstr);
+ if (!jthr) {
+ jthr = (*env)->ExceptionOccurred(env);
+ (*env)->ExceptionClear(env);
+ goto done;
+ }
+
+done:
+ free(msg);
+ va_end(ap2);
+ (*env)->DeleteLocalRef(env, jstr);
+ return jthr;
+}
+
+jthrowable newException(JNIEnv* env, const char *name, const char *fmt, ...)
+{
+ va_list ap;
+ jthrowable jthr;
+
+ va_start(ap, fmt);
+ jthr = newExceptionV(env, name, fmt, ap);
+ va_end(ap);
+ return jthr;
+}
+
+jthrowable newRuntimeException(JNIEnv* env, const char *fmt, ...)
+{
+ va_list ap;
+ jthrowable jthr;
+
+ va_start(ap, fmt);
+ jthr = newExceptionV(env, "java/lang/RuntimeException", fmt, ap);
+ va_end(ap);
+ return jthr;
+}
+
+jthrowable newIOException(JNIEnv* env, const char *fmt, ...)
+{
+ va_list ap;
+ jthrowable jthr;
+
+ va_start(ap, fmt);
+ jthr = newExceptionV(env, "java/io/IOException", fmt, ap);
+ va_end(ap);
+ return jthr;
+}
+
+const char* terror(int errnum)
+{
+
+#if defined(__sun)
+// MT-Safe under Solaris which doesn't support sys_errlist/sys_nerr
+ return strerror(errnum);
+#else
+ if ((errnum < 0) || (errnum >= sys_nerr)) {
+ return "unknown error.";
+ }
+ return sys_errlist[errnum];
+#endif
+}
+
diff --git a/ratis-common/src/main/native/src/exception.h b/ratis-common/src/main/native/src/exception.h
new file mode 100644
index 0000000000..1aea296433
--- /dev/null
+++ b/ratis-common/src/main/native/src/exception.h
@@ -0,0 +1,104 @@
+/*
+ * 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.
+ */
+#ifndef RATIS_MAIN_NATIVE_SRC_EXCEPTION_H
+#define RATIS_MAIN_NATIVE_SRC_EXCEPTION_H
+
+#include /* for jthrowable */
+#include /* for va_list */
+#include "org_apache_ratis.h"
+
+#ifdef WINDOWS
+/*
+ * gcc-style type-checked format arguments are not supported on Windows, so just
+ * stub this macro.
+ */
+#define TYPE_CHECKED_PRINTF_FORMAT(formatArg, varArgs)
+# else
+/* Use gcc type-checked format arguments. */
+#define TYPE_CHECKED_PRINTF_FORMAT(formatArg, varArgs) \
+ __attribute__((format(printf, formatArg, varArgs)))
+#endif
+
+/**
+ * Create a new Exception.
+ *
+ * No exceptions will be pending on return.
+ *
+ * @param env The JNI environment
+ * @param name full name of the Java exception class
+ * @param fmt printf-style format string
+ * @param ap printf-style arguments
+ *
+ * @return The RuntimeException
+ */
+jthrowable newExceptionV(JNIEnv* env, const char *name,
+ const char *fmt, va_list ap);
+
+/**
+ * Create a new Exception.
+ *
+ * No exceptions will be pending on return.
+ *
+ * @param env The JNI environment
+ * @param name full name of the Java exception class
+ * @param fmt printf-style format string
+ * @param ... printf-style arguments
+ *
+ * @return The RuntimeException
+ */
+jthrowable newException(JNIEnv* env, const char *name, const char *fmt, ...)
+ TYPE_CHECKED_PRINTF_FORMAT(3, 4);
+
+/**
+ * Create a new RuntimeException.
+ *
+ * No exceptions will be pending on return.
+ *
+ * @param env The JNI environment
+ * @param fmt printf-style format string
+ * @param ... printf-style arguments
+ *
+ * @return The RuntimeException
+ */
+jthrowable newRuntimeException(JNIEnv* env, const char *fmt, ...)
+ TYPE_CHECKED_PRINTF_FORMAT(2, 3);
+
+/**
+ * Create a new IOException.
+ *
+ * No exceptions will be pending on return.
+ *
+ * @param env The JNI environment
+ * @param fmt printf-style format string
+ * @param ... printf-style arguments
+ *
+ * @return The IOException, or another exception if we failed
+ * to create the NativeIOException.
+ */
+jthrowable newIOException(JNIEnv* env, const char *fmt, ...)
+ TYPE_CHECKED_PRINTF_FORMAT(2, 3);
+
+/**
+ * Thread-safe strerror alternative.
+ *
+ * @param errnum Error number.
+ * @return Statically allocated error string.
+ */
+const char* terror(int errnum);
+
+#undef TYPE_CHECKED_PRINTF_FORMAT
+#endif
diff --git a/ratis-common/src/main/native/src/org/apache/ratis/io/nativeio/NativeIO.c b/ratis-common/src/main/native/src/org/apache/ratis/io/nativeio/NativeIO.c
new file mode 100644
index 0000000000..e315c41bac
--- /dev/null
+++ b/ratis-common/src/main/native/src/org/apache/ratis/io/nativeio/NativeIO.c
@@ -0,0 +1,1061 @@
+/*
+ * 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.
+ */
+
+#include "org_apache_ratis.h"
+#include "org_apache_ratis_io_nativeio_NativeIO.h"
+#include "org_apache_ratis_io_nativeio_NativeIO_POSIX.h"
+#include "exception.h"
+
+#ifdef UNIX
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#if !(defined(__FreeBSD__) || defined(__MACH__))
+#include
+#endif
+#include
+#include
+#include
+#include "config.h"
+#endif
+
+#ifdef WINDOWS
+#include
+#include
+#include "winutils.h"
+#endif
+
+#include "file_descriptor.h"
+#include "errno_enum.h"
+
+#define MMAP_PROT_READ org_apache_ratis_io_nativeio_NativeIO_POSIX_MMAP_PROT_READ
+#define MMAP_PROT_WRITE org_apache_ratis_io_nativeio_NativeIO_POSIX_MMAP_PROT_WRITE
+#define MMAP_PROT_EXEC org_apache_ratis_io_nativeio_NativeIO_POSIX_MMAP_PROT_EXEC
+
+#define NATIVE_IO_POSIX_CLASS "org/apache/ratis/io/nativeio/NativeIO$POSIX"
+#define NATIVE_IO_STAT_CLASS "org/apache/ratis/io/nativeio/NativeIO$POSIX$Stat"
+
+#define SET_INT_OR_RETURN(E, C, F) \
+ { \
+ setStaticInt(E, C, #F, F); \
+ if ((*E)->ExceptionCheck(E)) return; \
+ }
+
+// the NativeIO$POSIX$Stat inner class and its constructor
+static jclass stat_clazz;
+static jmethodID stat_ctor;
+static jmethodID stat_ctor2;
+
+// the NativeIOException class and its constructor
+static jclass nioe_clazz;
+static jmethodID nioe_ctor;
+
+// the monitor used for working around non-threadsafe implementations
+// of getpwuid_r, observed on platforms including RHEL 6.0.
+// Please see HADOOP-7156 for details.
+jobject pw_lock_object;
+
+/*
+ * Throw a java.IO.IOException, generating the message from errno.
+ * NB. this is also used form windows_secure_container_executor.c
+ */
+extern void throw_ioe(JNIEnv* env, int errnum);
+
+// Internal functions
+#ifdef UNIX
+static ssize_t get_pw_buflen();
+#endif
+
+/**
+ * Returns non-zero if the user has specified that the system
+ * has non-threadsafe implementations of getpwuid_r or getgrgid_r.
+ **/
+static int workaround_non_threadsafe_calls(JNIEnv *env, jclass clazz) {
+ jboolean result;
+ jfieldID needs_workaround_field = (*env)->GetStaticFieldID(
+ env, clazz,
+ "workaroundNonThreadSafePasswdCalls",
+ "Z");
+ PASS_EXCEPTIONS_RET(env, 0);
+ assert(needs_workaround_field);
+
+ result = (*env)->GetStaticBooleanField(
+ env, clazz, needs_workaround_field);
+ return result;
+}
+
+/**
+ * Sets a static boolean field to the specified value.
+ */
+static void setStaticBoolean(JNIEnv *env, jclass clazz, char *field,
+ jboolean val) {
+ jfieldID fid = (*env)->GetStaticFieldID(env, clazz, field, "Z");
+ if (fid != NULL) {
+ (*env)->SetStaticBooleanField(env, clazz, fid, val);
+ }
+}
+
+/**
+ * Sets a static int field to the specified value.
+ */
+static void setStaticInt(JNIEnv *env, jclass clazz, char *field,
+ jint val) {
+ jfieldID fid = (*env)->GetStaticFieldID(env, clazz, field, "I");
+ if (fid != NULL) {
+ (*env)->SetStaticIntField(env, clazz, fid, val);
+ }
+}
+
+#ifdef UNIX
+/**
+ * Initialises a list of java constants that are platform specific.
+ * These are only initialized in UNIX.
+ * Any exceptions that occur will be dealt at the level above.
+**/
+static void consts_init(JNIEnv *env) {
+ jclass clazz = (*env)->FindClass(env, NATIVE_IO_POSIX_CLASS);
+ if (clazz == NULL) {
+ return; // exception has been raised
+ }
+ SET_INT_OR_RETURN(env, clazz, O_RDONLY);
+ SET_INT_OR_RETURN(env, clazz, O_WRONLY);
+ SET_INT_OR_RETURN(env, clazz, O_RDWR);
+ SET_INT_OR_RETURN(env, clazz, O_CREAT);
+ SET_INT_OR_RETURN(env, clazz, O_EXCL);
+ SET_INT_OR_RETURN(env, clazz, O_NOCTTY);
+ SET_INT_OR_RETURN(env, clazz, O_TRUNC);
+ SET_INT_OR_RETURN(env, clazz, O_APPEND);
+ SET_INT_OR_RETURN(env, clazz, O_NONBLOCK);
+ SET_INT_OR_RETURN(env, clazz, O_SYNC);
+#ifdef HAVE_POSIX_FADVISE
+ setStaticBoolean(env, clazz, "fadvisePossible", JNI_TRUE);
+ SET_INT_OR_RETURN(env, clazz, POSIX_FADV_NORMAL);
+ SET_INT_OR_RETURN(env, clazz, POSIX_FADV_RANDOM);
+ SET_INT_OR_RETURN(env, clazz, POSIX_FADV_SEQUENTIAL);
+ SET_INT_OR_RETURN(env, clazz, POSIX_FADV_WILLNEED);
+ SET_INT_OR_RETURN(env, clazz, POSIX_FADV_DONTNEED);
+ SET_INT_OR_RETURN(env, clazz, POSIX_FADV_NOREUSE);
+#else
+ setStaticBoolean(env, clazz, "fadvisePossible", JNI_FALSE);
+#endif
+#ifdef HAVE_SYNC_FILE_RANGE
+ SET_INT_OR_RETURN(env, clazz, SYNC_FILE_RANGE_WAIT_BEFORE);
+ SET_INT_OR_RETURN(env, clazz, SYNC_FILE_RANGE_WRITE);
+ SET_INT_OR_RETURN(env, clazz, SYNC_FILE_RANGE_WAIT_AFTER);
+#endif
+ clazz = (*env)->FindClass(env, NATIVE_IO_STAT_CLASS);
+ if (clazz == NULL) {
+ return; // exception has been raised
+ }
+ SET_INT_OR_RETURN(env, clazz, S_IFMT);
+ SET_INT_OR_RETURN(env, clazz, S_IFIFO);
+ SET_INT_OR_RETURN(env, clazz, S_IFCHR);
+ SET_INT_OR_RETURN(env, clazz, S_IFDIR);
+ SET_INT_OR_RETURN(env, clazz, S_IFBLK);
+ SET_INT_OR_RETURN(env, clazz, S_IFREG);
+ SET_INT_OR_RETURN(env, clazz, S_IFLNK);
+ SET_INT_OR_RETURN(env, clazz, S_IFSOCK);
+ SET_INT_OR_RETURN(env, clazz, S_ISUID);
+ SET_INT_OR_RETURN(env, clazz, S_ISGID);
+ SET_INT_OR_RETURN(env, clazz, S_ISVTX);
+ SET_INT_OR_RETURN(env, clazz, S_IRUSR);
+ SET_INT_OR_RETURN(env, clazz, S_IWUSR);
+ SET_INT_OR_RETURN(env, clazz, S_IXUSR);
+}
+#endif
+
+static void stat_init(JNIEnv *env, jclass nativeio_class) {
+ jclass clazz = NULL;
+ jclass obj_class = NULL;
+ jmethodID obj_ctor = NULL;
+ // Init Stat
+ clazz = (*env)->FindClass(env, NATIVE_IO_STAT_CLASS);
+ if (!clazz) {
+ return; // exception has been raised
+ }
+ stat_clazz = (*env)->NewGlobalRef(env, clazz);
+ if (!stat_clazz) {
+ return; // exception has been raised
+ }
+ stat_ctor = (*env)->GetMethodID(env, stat_clazz, "",
+ "(III)V");
+ if (!stat_ctor) {
+ return; // exception has been raised
+ }
+ stat_ctor2 = (*env)->GetMethodID(env, stat_clazz, "",
+ "(Ljava/lang/String;Ljava/lang/String;I)V");
+ if (!stat_ctor2) {
+ return; // exception has been raised
+ }
+ obj_class = (*env)->FindClass(env, "java/lang/Object");
+ if (!obj_class) {
+ return; // exception has been raised
+ }
+ obj_ctor = (*env)->GetMethodID(env, obj_class,
+ "", "()V");
+ if (!obj_ctor) {
+ return; // exception has been raised
+ }
+
+ if (workaround_non_threadsafe_calls(env, nativeio_class)) {
+ pw_lock_object = (*env)->NewObject(env, obj_class, obj_ctor);
+ PASS_EXCEPTIONS(env);
+ pw_lock_object = (*env)->NewGlobalRef(env, pw_lock_object);
+
+ PASS_EXCEPTIONS(env);
+ }
+}
+
+static void stat_deinit(JNIEnv *env) {
+ if (stat_clazz != NULL) {
+ (*env)->DeleteGlobalRef(env, stat_clazz);
+ stat_clazz = NULL;
+ }
+ if (pw_lock_object != NULL) {
+ (*env)->DeleteGlobalRef(env, pw_lock_object);
+ pw_lock_object = NULL;
+ }
+}
+
+static void nioe_init(JNIEnv *env) {
+ // Init NativeIOException
+ nioe_clazz = (*env)->FindClass(
+ env, "org/apache/ratis/io/nativeio/NativeIOException");
+ PASS_EXCEPTIONS(env);
+
+ nioe_clazz = (*env)->NewGlobalRef(env, nioe_clazz);
+#ifdef UNIX
+ nioe_ctor = (*env)->GetMethodID(env, nioe_clazz, "",
+ "(Ljava/lang/String;Lorg/apache/ratis/io/nativeio/Errno;)V");
+#endif
+
+#ifdef WINDOWS
+ nioe_ctor = (*env)->GetMethodID(env, nioe_clazz, "",
+ "(Ljava/lang/String;I)V");
+#endif
+}
+
+static void nioe_deinit(JNIEnv *env) {
+ if (nioe_clazz != NULL) {
+ (*env)->DeleteGlobalRef(env, nioe_clazz);
+ nioe_clazz = NULL;
+ }
+ nioe_ctor = NULL;
+}
+
+/*
+ * private static native void initNative();
+ *
+ * We rely on this function rather than lazy initialization because
+ * the lazy approach may have a race if multiple callers try to
+ * init at the same time.
+ */
+JNIEXPORT void JNICALL
+Java_org_apache_ratis_io_nativeio_NativeIO_initNative(
+ JNIEnv *env, jclass clazz) {
+#ifdef UNIX
+ consts_init(env);
+ PASS_EXCEPTIONS_GOTO(env, error);
+#endif
+ stat_init(env, clazz);
+ PASS_EXCEPTIONS_GOTO(env, error);
+ nioe_init(env);
+ PASS_EXCEPTIONS_GOTO(env, error);
+ fd_init(env);
+ PASS_EXCEPTIONS_GOTO(env, error);
+#ifdef UNIX
+ errno_enum_init(env);
+ PASS_EXCEPTIONS_GOTO(env, error);
+#endif
+ return;
+error:
+ // these are all idempodent and safe to call even if the
+ // class wasn't initted yet
+#ifdef UNIX
+ stat_deinit(env);
+#endif
+ nioe_deinit(env);
+ fd_deinit(env);
+#ifdef UNIX
+ errno_enum_deinit(env);
+#endif
+}
+
+/*
+ * Class: org_apache_ratis_io_nativeio_NativeIO_POSIX
+ * Method: fstat
+ * Signature: (Ljava/io/FileDescriptor;)Lorg/apache/ratis/io/nativeio/NativeIO$POSIX$Stat;
+ * public static native Stat fstat(FileDescriptor fd);
+ *
+ * The "00024" in the function name is an artifact of how JNI encodes
+ * special characters. U+0024 is '$'.
+ */
+JNIEXPORT jobject JNICALL
+Java_org_apache_ratis_io_nativeio_NativeIO_00024POSIX_fstat(
+ JNIEnv *env, jclass clazz, jobject fd_object)
+{
+#ifdef UNIX
+ jobject ret = NULL;
+
+ int fd = fd_get(env, fd_object);
+ PASS_EXCEPTIONS_GOTO(env, cleanup);
+
+ struct stat s;
+ int rc = fstat(fd, &s);
+ if (rc != 0) {
+ throw_ioe(env, errno);
+ goto cleanup;
+ }
+
+ // Construct result
+ ret = (*env)->NewObject(env, stat_clazz, stat_ctor,
+ (jint)s.st_uid, (jint)s.st_gid, (jint)s.st_mode);
+
+cleanup:
+ return ret;
+#endif
+
+#ifdef WINDOWS
+ LPWSTR owner = NULL;
+ LPWSTR group = NULL;
+ int mode = 0;
+ jstring jstr_owner = NULL;
+ jstring jstr_group = NULL;
+ int rc;
+ jobject ret = NULL;
+ HANDLE hFile = (HANDLE) fd_get(env, fd_object);
+ PASS_EXCEPTIONS_GOTO(env, cleanup);
+
+ rc = FindFileOwnerAndPermissionByHandle(hFile, &owner, &group, &mode);
+ if (rc != ERROR_SUCCESS) {
+ throw_ioe(env, rc);
+ goto cleanup;
+ }
+
+ jstr_owner = (*env)->NewString(env, owner, (jsize) wcslen(owner));
+ if (jstr_owner == NULL) goto cleanup;
+
+ jstr_group = (*env)->NewString(env, group, (jsize) wcslen(group));;
+ if (jstr_group == NULL) goto cleanup;
+
+ ret = (*env)->NewObject(env, stat_clazz, stat_ctor2,
+ jstr_owner, jstr_group, (jint)mode);
+
+cleanup:
+ if (ret == NULL) {
+ if (jstr_owner != NULL)
+ (*env)->ReleaseStringChars(env, jstr_owner, owner);
+
+ if (jstr_group != NULL)
+ (*env)->ReleaseStringChars(env, jstr_group, group);
+ }
+
+ LocalFree(owner);
+ LocalFree(group);
+
+ return ret;
+#endif
+}
+
+
+
+/**
+ * public static native void posix_fadvise(
+ * FileDescriptor fd, long offset, long len, int flags);
+ *
+ * The "00024" in the function name is an artifact of how JNI encodes
+ * special characters. U+0024 is '$'.
+ */
+JNIEXPORT void JNICALL
+Java_org_apache_ratis_io_nativeio_NativeIO_00024POSIX_posix_1fadvise(
+ JNIEnv *env, jclass clazz,
+ jobject fd_object, jlong offset, jlong len, jint flags)
+{
+#ifndef HAVE_POSIX_FADVISE
+ THROW(env, "java/lang/UnsupportedOperationException",
+ "fadvise support not available");
+#else
+ int fd = fd_get(env, fd_object);
+ PASS_EXCEPTIONS(env);
+
+ int err = 0;
+ if ((err = posix_fadvise(fd, (off_t)offset, (off_t)len, flags))) {
+#ifdef __FreeBSD__
+ throw_ioe(env, errno);
+#else
+ throw_ioe(env, err);
+#endif
+ }
+#endif
+}
+
+#if defined(HAVE_SYNC_FILE_RANGE)
+# define my_sync_file_range sync_file_range
+#elif defined(SYS_sync_file_range)
+// RHEL 5 kernels have sync_file_range support, but the glibc
+// included does not have the library function. We can
+// still call it directly, and if it's not supported by the
+// kernel, we'd get ENOSYS. See RedHat Bugzilla #518581
+static int manual_sync_file_range (int fd, __off64_t from, __off64_t to, unsigned int flags)
+{
+#ifdef __x86_64__
+ return syscall( SYS_sync_file_range, fd, from, to, flags);
+#else
+ return syscall (SYS_sync_file_range, fd,
+ __LONG_LONG_PAIR ((long) (from >> 32), (long) from),
+ __LONG_LONG_PAIR ((long) (to >> 32), (long) to),
+ flags);
+#endif
+}
+#define my_sync_file_range manual_sync_file_range
+#endif
+
+/**
+ * public static native void sync_file_range(
+ * FileDescriptor fd, long offset, long len, int flags);
+ *
+ * The "00024" in the function name is an artifact of how JNI encodes
+ * special characters. U+0024 is '$'.
+ */
+JNIEXPORT void JNICALL
+Java_org_apache_ratis_io_nativeio_NativeIO_00024POSIX_sync_1file_1range(
+ JNIEnv *env, jclass clazz,
+ jobject fd_object, jlong offset, jlong len, jint flags)
+{
+#ifndef my_sync_file_range
+ THROW(env, "java/lang/UnsupportedOperationException",
+ "sync_file_range support not available");
+#else
+ int fd = fd_get(env, fd_object);
+ PASS_EXCEPTIONS(env);
+
+ if (my_sync_file_range(fd, (off_t)offset, (off_t)len, flags)) {
+ if (errno == ENOSYS) {
+ // we know the syscall number, but it's not compiled
+ // into the running kernel
+ THROW(env, "java/lang/UnsupportedOperationException",
+ "sync_file_range kernel support not available");
+ return;
+ } else {
+ throw_ioe(env, errno);
+ }
+ }
+#endif
+}
+
+#define CHECK_DIRECT_BUFFER_ADDRESS(buf) \
+ { \
+ if (!buf) { \
+ THROW(env, "java/lang/UnsupportedOperationException", \
+ "JNI access to direct buffers not available"); \
+ return; \
+ } \
+ }
+
+/**
+ * public static native void mlock_native(
+ * ByteBuffer buffer, long offset);
+ *
+ * The "00024" in the function name is an artifact of how JNI encodes
+ * special characters. U+0024 is '$'.
+ */
+JNIEXPORT void JNICALL
+Java_org_apache_ratis_io_nativeio_NativeIO_00024POSIX_mlock_1native(
+ JNIEnv *env, jclass clazz,
+ jobject buffer, jlong len)
+{
+ void* buf = (void*)(*env)->GetDirectBufferAddress(env, buffer);
+ PASS_EXCEPTIONS(env);
+
+#ifdef UNIX
+ if (mlock(buf, len)) {
+ CHECK_DIRECT_BUFFER_ADDRESS(buf);
+ throw_ioe(env, errno);
+ }
+#endif
+
+#ifdef WINDOWS
+ if (!VirtualLock(buf, len)) {
+ CHECK_DIRECT_BUFFER_ADDRESS(buf);
+ throw_ioe(env, GetLastError());
+ }
+#endif
+}
+
+/*
+ * Class: org_apache_ratis_io_nativeio_NativeIO_POSIX
+ * Method: open
+ * Signature: (Ljava/lang/String;II)Ljava/io/FileDescriptor;
+ * public static native FileDescriptor open(String path, int flags, int mode);
+ *
+ * The "00024" in the function name is an artifact of how JNI encodes
+ * special characters. U+0024 is '$'.
+ */
+JNIEXPORT jobject JNICALL
+Java_org_apache_ratis_io_nativeio_NativeIO_00024POSIX_open(
+ JNIEnv *env, jclass clazz, jstring j_path,
+ jint flags, jint mode)
+{
+#ifdef UNIX
+ jobject ret = NULL;
+
+ const char *path = (*env)->GetStringUTFChars(env, j_path, NULL);
+ if (path == NULL) goto cleanup; // JVM throws Exception for us
+
+ int fd;
+ if (flags & O_CREAT) {
+ fd = open(path, flags, mode);
+ } else {
+ fd = open(path, flags);
+ }
+
+ if (fd == -1) {
+ throw_ioe(env, errno);
+ goto cleanup;
+ }
+
+ ret = fd_create(env, fd);
+
+cleanup:
+ if (path != NULL) {
+ (*env)->ReleaseStringUTFChars(env, j_path, path);
+ }
+ return ret;
+#endif
+
+#ifdef WINDOWS
+ THROW(env, "java/io/IOException",
+ "The function POSIX.open() is not supported on Windows");
+ return NULL;
+#endif
+}
+
+/*
+ * Class: org_apache_ratis_io_nativeio_NativeIO_Windows
+ * Method: createDirectoryWithMode0
+ * Signature: (Ljava/lang/String;I)V
+ *
+ * The "00024" in the function name is an artifact of how JNI encodes
+ * special characters. U+0024 is '$'.
+ */
+JNIEXPORT void JNICALL
+ Java_org_apache_ratis_io_nativeio_NativeIO_00024Windows_createDirectoryWithMode0
+ (JNIEnv *env, jclass clazz, jstring j_path, jint mode)
+{
+#ifdef WINDOWS
+ DWORD dwRtnCode = ERROR_SUCCESS;
+
+ LPCWSTR path = (LPCWSTR) (*env)->GetStringChars(env, j_path, NULL);
+ if (!path) {
+ goto done;
+ }
+
+ dwRtnCode = CreateDirectoryWithMode(path, mode);
+
+done:
+ if (path) {
+ (*env)->ReleaseStringChars(env, j_path, (const jchar*) path);
+ }
+ if (dwRtnCode != ERROR_SUCCESS) {
+ throw_ioe(env, dwRtnCode);
+ }
+#else
+ THROW(env, "java/io/IOException",
+ "The function Windows.createDirectoryWithMode0() is not supported on this platform");
+#endif
+}
+
+/*
+ * Class: org_apache_ratis_io_nativeio_NativeIO_Windows
+ * Method: createFileWithMode0
+ * Signature: (Ljava/lang/String;JJJI)Ljava/io/FileDescriptor;
+ *
+ * The "00024" in the function name is an artifact of how JNI encodes
+ * special characters. U+0024 is '$'.
+ */
+JNIEXPORT jobject JNICALL
+ Java_org_apache_ratis_io_nativeio_NativeIO_00024Windows_createFileWithMode0
+ (JNIEnv *env, jclass clazz, jstring j_path,
+ jlong desiredAccess, jlong shareMode, jlong creationDisposition, jint mode)
+{
+#ifdef WINDOWS
+ DWORD dwRtnCode = ERROR_SUCCESS;
+ HANDLE hFile = INVALID_HANDLE_VALUE;
+ jobject fd = NULL;
+
+ LPCWSTR path = (LPCWSTR) (*env)->GetStringChars(env, j_path, NULL);
+ if (!path) {
+ goto done;
+ }
+
+ dwRtnCode = CreateFileWithMode(path, desiredAccess, shareMode,
+ creationDisposition, mode, &hFile);
+ if (dwRtnCode != ERROR_SUCCESS) {
+ goto done;
+ }
+
+ fd = fd_create(env, (long) hFile);
+
+done:
+ if (path) {
+ (*env)->ReleaseStringChars(env, j_path, (const jchar*) path);
+ }
+ if (dwRtnCode != ERROR_SUCCESS) {
+ throw_ioe(env, dwRtnCode);
+ }
+ return fd;
+#else
+ THROW(env, "java/io/IOException",
+ "The function Windows.createFileWithMode0() is not supported on this platform");
+ return NULL;
+#endif
+}
+
+/*
+ * Class: org_apache_ratis_io_nativeio_NativeIO_Windows
+ * Method: createFile
+ * Signature: (Ljava/lang/String;JJJ)Ljava/io/FileDescriptor;
+ *
+ * The "00024" in the function name is an artifact of how JNI encodes
+ * special characters. U+0024 is '$'.
+ */
+JNIEXPORT jobject JNICALL Java_org_apache_ratis_io_nativeio_NativeIO_00024Windows_createFile
+ (JNIEnv *env, jclass clazz, jstring j_path,
+ jlong desiredAccess, jlong shareMode, jlong creationDisposition)
+{
+#ifdef UNIX
+ THROW(env, "java/io/IOException",
+ "The function Windows.createFile() is not supported on Unix");
+ return NULL;
+#endif
+
+#ifdef WINDOWS
+ DWORD dwRtnCode = ERROR_SUCCESS;
+ BOOL isSymlink = FALSE;
+ BOOL isJunction = FALSE;
+ DWORD dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS;
+ jobject ret = (jobject) NULL;
+ HANDLE hFile = INVALID_HANDLE_VALUE;
+ WCHAR *path = (WCHAR *) (*env)->GetStringChars(env, j_path, (jboolean*)NULL);
+ if (path == NULL) goto cleanup;
+
+ // Set the flag for a symbolic link or a junctions point only when it exists.
+ // According to MSDN if the call to CreateFile() function creates a file,
+ // there is no change in behavior. So we do not throw if no file is found.
+ //
+ dwRtnCode = SymbolicLinkCheck(path, &isSymlink);
+ if (dwRtnCode != ERROR_SUCCESS && dwRtnCode != ERROR_FILE_NOT_FOUND) {
+ throw_ioe(env, dwRtnCode);
+ goto cleanup;
+ }
+ dwRtnCode = JunctionPointCheck(path, &isJunction);
+ if (dwRtnCode != ERROR_SUCCESS && dwRtnCode != ERROR_FILE_NOT_FOUND) {
+ throw_ioe(env, dwRtnCode);
+ goto cleanup;
+ }
+ if (isSymlink || isJunction)
+ dwFlagsAndAttributes |= FILE_FLAG_OPEN_REPARSE_POINT;
+
+ hFile = CreateFile(path,
+ (DWORD) desiredAccess,
+ (DWORD) shareMode,
+ (LPSECURITY_ATTRIBUTES ) NULL,
+ (DWORD) creationDisposition,
+ dwFlagsAndAttributes,
+ NULL);
+ if (hFile == INVALID_HANDLE_VALUE) {
+ throw_ioe(env, GetLastError());
+ goto cleanup;
+ }
+
+ ret = fd_create(env, (long) hFile);
+cleanup:
+ if (path != NULL) {
+ (*env)->ReleaseStringChars(env, j_path, (const jchar*)path);
+ }
+ return (jobject) ret;
+#endif
+}
+
+/*
+ * Class: org_apache_ratis_io_nativeio_NativeIO_POSIX
+ * Method: chmod
+ * Signature: (Ljava/lang/String;I)V
+ */
+JNIEXPORT void JNICALL Java_org_apache_ratis_io_nativeio_NativeIO_00024POSIX_chmodImpl
+ (JNIEnv *env, jclass clazz, jstring j_path, jint mode)
+{
+#ifdef UNIX
+ const char *path = (*env)->GetStringUTFChars(env, j_path, NULL);
+ if (path == NULL) return; // JVM throws Exception for us
+
+ if (chmod(path, mode) != 0) {
+ throw_ioe(env, errno);
+ }
+
+ (*env)->ReleaseStringUTFChars(env, j_path, path);
+#endif
+
+#ifdef WINDOWS
+ DWORD dwRtnCode = ERROR_SUCCESS;
+ LPCWSTR path = (LPCWSTR) (*env)->GetStringChars(env, j_path, NULL);
+ if (path == NULL) return; // JVM throws Exception for us
+
+ if ((dwRtnCode = ChangeFileModeByMask((LPCWSTR) path, mode)) != ERROR_SUCCESS)
+ {
+ throw_ioe(env, dwRtnCode);
+ }
+
+ (*env)->ReleaseStringChars(env, j_path, (const jchar*) path);
+#endif
+}
+
+JNIEXPORT jlong JNICALL
+Java_org_apache_ratis_io_nativeio_NativeIO_00024POSIX_mmap(
+ JNIEnv *env, jclass clazz, jobject jfd, jint jprot,
+ jboolean jshared, jlong length)
+{
+#ifdef UNIX
+ void *addr = 0;
+ int prot, flags, fd;
+
+ prot = ((jprot & MMAP_PROT_READ) ? PROT_READ : 0) |
+ ((jprot & MMAP_PROT_WRITE) ? PROT_WRITE : 0) |
+ ((jprot & MMAP_PROT_EXEC) ? PROT_EXEC : 0);
+ flags = (jshared == JNI_TRUE) ? MAP_SHARED : MAP_PRIVATE;
+ fd = fd_get(env, jfd);
+ addr = mmap(NULL, length, prot, flags, fd, 0);
+ if (addr == MAP_FAILED) {
+ throw_ioe(env, errno);
+ }
+ return (jlong)(intptr_t)addr;
+#endif // UNIX
+
+#ifdef WINDOWS
+ THROW(env, "java/io/IOException",
+ "The function POSIX.mmap() is not supported on Windows");
+ return (jlong)(intptr_t)NULL;
+#endif
+}
+
+JNIEXPORT void JNICALL
+Java_org_apache_ratis_io_nativeio_NativeIO_00024POSIX_munmap(
+ JNIEnv *env, jclass clazz, jlong jaddr, jlong length)
+{
+#ifdef UNIX
+ void *addr;
+
+ addr = (void*)(intptr_t)jaddr;
+ if (munmap(addr, length) < 0) {
+ throw_ioe(env, errno);
+ }
+#endif // UNIX
+
+#ifdef WINDOWS
+ THROW(env, "java/io/IOException",
+ "The function POSIX.munmap() is not supported on Windows");
+#endif
+}
+
+/*
+ * Throw a java.IO.IOException, generating the message from errno.
+ */
+void throw_ioe(JNIEnv* env, int errnum)
+{
+#ifdef UNIX
+ char message[80];
+ jstring jstr_message;
+
+ snprintf(message,sizeof(message),"%s",terror(errnum));
+
+ jobject errno_obj = errno_to_enum(env, errnum);
+
+ if ((jstr_message = (*env)->NewStringUTF(env, message)) == NULL)
+ goto err;
+
+ jthrowable obj = (jthrowable)(*env)->NewObject(env, nioe_clazz, nioe_ctor,
+ jstr_message, errno_obj);
+ if (obj == NULL) goto err;
+
+ (*env)->Throw(env, obj);
+ return;
+
+err:
+ if (jstr_message != NULL)
+ (*env)->ReleaseStringUTFChars(env, jstr_message, message);
+#endif
+
+#ifdef WINDOWS
+ DWORD len = 0;
+ LPWSTR buffer = NULL;
+ const jchar* message = NULL;
+ jstring jstr_message = NULL;
+ jthrowable obj = NULL;
+
+ len = FormatMessageW(
+ FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+ NULL, *(DWORD*) (&errnum), // reinterpret cast
+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+ (LPWSTR) &buffer, 0, NULL);
+
+ if (len > 0)
+ {
+ message = (const jchar*) buffer;
+ }
+ else
+ {
+ message = (const jchar*) L"Unknown error.";
+ }
+
+ if ((jstr_message = (*env)->NewString(env, message, len)) == NULL)
+ goto err;
+ LocalFree(buffer);
+ buffer = NULL; // Set buffer to NULL to avoid double free
+
+ obj = (jthrowable)(*env)->NewObject(env, nioe_clazz, nioe_ctor,
+ jstr_message, errnum);
+ if (obj == NULL) goto err;
+
+ (*env)->Throw(env, obj);
+ return;
+
+err:
+ if (jstr_message != NULL)
+ (*env)->ReleaseStringChars(env, jstr_message, message);
+ LocalFree(buffer);
+ return;
+#endif
+}
+
+#ifdef UNIX
+/*
+ * Determine how big a buffer we need for reentrant getpwuid_r and getgrnam_r
+ */
+ssize_t get_pw_buflen() {
+ long ret = 0;
+ #ifdef _SC_GETPW_R_SIZE_MAX
+ ret = sysconf(_SC_GETPW_R_SIZE_MAX);
+ #endif
+ return (ret > 512) ? ret : 512;
+}
+#endif
+
+/*
+ * Class: org_apache_ratis_io_nativeio_NativeIO_Windows
+ * Method: setFilePointer
+ * Signature: (Ljava/io/FileDescriptor;JJ)J
+ *
+ * The "00024" in the function name is an artifact of how JNI encodes
+ * special characters. U+0024 is '$'.
+ */
+JNIEXPORT jlong JNICALL
+Java_org_apache_ratis_io_nativeio_NativeIO_00024Windows_setFilePointer
+ (JNIEnv *env, jclass clazz, jobject fd_object, jlong distanceToMove, jlong moveMethod)
+{
+#ifdef UNIX
+ THROW(env, "java/io/IOException",
+ "The function setFilePointer(FileDescriptor) is not supported on Unix");
+ return (jlong)(intptr_t)NULL;
+#endif
+
+#ifdef WINDOWS
+ DWORD distanceToMoveLow = (DWORD) distanceToMove;
+ LONG distanceToMoveHigh = (LONG) (distanceToMove >> 32);
+ DWORD distanceMovedLow = 0;
+ HANDLE hFile = (HANDLE) fd_get(env, fd_object);
+ PASS_EXCEPTIONS_GOTO(env, cleanup);
+
+ distanceMovedLow = SetFilePointer(hFile,
+ distanceToMoveLow, &distanceToMoveHigh, (DWORD) moveMethod);
+
+ if (distanceMovedLow == INVALID_SET_FILE_POINTER) {
+ throw_ioe(env, GetLastError());
+ return -1;
+ }
+
+cleanup:
+
+ return ((jlong) distanceToMoveHigh << 32) | (jlong) distanceMovedLow;
+#endif
+}
+
+/*
+ * Class: org_apache_ratis_io_nativeio_NativeIO_Windows
+ * Method: access0
+ * Signature: (Ljava/lang/String;I)Z
+ */
+JNIEXPORT jboolean JNICALL Java_org_apache_ratis_io_nativeio_NativeIO_00024Windows_access0
+ (JNIEnv *env, jclass clazz, jstring jpath, jint jaccess)
+{
+#ifdef UNIX
+ THROW(env, "java/io/IOException",
+ "The function access0(path, access) is not supported on Unix");
+ return (jlong)(intptr_t)NULL;
+#endif
+
+#ifdef WINDOWS
+ LPCWSTR path = NULL;
+ DWORD dwRtnCode = ERROR_SUCCESS;
+ ACCESS_MASK access = (ACCESS_MASK)jaccess;
+ BOOL allowed = FALSE;
+
+ path = (LPCWSTR) (*env)->GetStringChars(env, jpath, NULL);
+ if (!path) goto cleanup; // exception was thrown
+
+ dwRtnCode = CheckAccessForCurrentUser(path, access, &allowed);
+ if (dwRtnCode != ERROR_SUCCESS) {
+ throw_ioe(env, dwRtnCode);
+ goto cleanup;
+ }
+
+cleanup:
+ if (path) (*env)->ReleaseStringChars(env, jpath, path);
+
+ return (jboolean)allowed;
+#endif
+}
+
+/*
+ * Class: org_apache_ratis_io_nativeio_NativeIO_Windows
+ * Method: extendWorkingSetSize
+ * Signature: (J)V
+ *
+ * The "00024" in the function name is an artifact of how JNI encodes
+ * special characters. U+0024 is '$'.
+ */
+JNIEXPORT void JNICALL
+Java_org_apache_ratis_io_nativeio_NativeIO_00024Windows_extendWorkingSetSize(
+ JNIEnv *env, jclass clazz, jlong delta)
+{
+#ifdef UNIX
+ THROW(env, "java/io/IOException",
+ "The function extendWorkingSetSize(delta) is not supported on Unix");
+#endif
+
+#ifdef WINDOWS
+ SIZE_T min, max;
+ HANDLE hProcess = GetCurrentProcess();
+ if (!GetProcessWorkingSetSize(hProcess, &min, &max)) {
+ throw_ioe(env, GetLastError());
+ return;
+ }
+ if (!SetProcessWorkingSetSizeEx(hProcess, min + delta, max + delta,
+ QUOTA_LIMITS_HARDWS_MIN_DISABLE | QUOTA_LIMITS_HARDWS_MAX_DISABLE)) {
+ throw_ioe(env, GetLastError());
+ return;
+ }
+ // There is no need to call CloseHandle on the pseudo-handle returned from
+ // GetCurrentProcess.
+#endif
+}
+
+JNIEXPORT void JNICALL
+Java_org_apache_ratis_io_nativeio_NativeIO_renameTo0(JNIEnv *env,
+jclass clazz, jstring jsrc, jstring jdst)
+{
+#ifdef UNIX
+ const char *src = NULL, *dst = NULL;
+
+ src = (*env)->GetStringUTFChars(env, jsrc, NULL);
+ if (!src) goto done; // exception was thrown
+ dst = (*env)->GetStringUTFChars(env, jdst, NULL);
+ if (!dst) goto done; // exception was thrown
+ if (rename(src, dst)) {
+ throw_ioe(env, errno);
+ }
+
+done:
+ if (src) (*env)->ReleaseStringUTFChars(env, jsrc, src);
+ if (dst) (*env)->ReleaseStringUTFChars(env, jdst, dst);
+#endif
+
+#ifdef WINDOWS
+ LPCWSTR src = NULL, dst = NULL;
+
+ src = (LPCWSTR) (*env)->GetStringChars(env, jsrc, NULL);
+ if (!src) goto done; // exception was thrown
+ dst = (LPCWSTR) (*env)->GetStringChars(env, jdst, NULL);
+ if (!dst) goto done; // exception was thrown
+ if (!MoveFile(src, dst)) {
+ throw_ioe(env, GetLastError());
+ }
+
+done:
+ if (src) (*env)->ReleaseStringChars(env, jsrc, src);
+ if (dst) (*env)->ReleaseStringChars(env, jdst, dst);
+#endif
+}
+
+JNIEXPORT jlong JNICALL
+Java_org_apache_ratis_io_nativeio_NativeIO_getMemlockLimit0(
+JNIEnv *env, jclass clazz)
+{
+#ifdef RLIMIT_MEMLOCK
+ struct rlimit rlim;
+ int rc = getrlimit(RLIMIT_MEMLOCK, &rlim);
+ if (rc != 0) {
+ throw_ioe(env, errno);
+ return 0;
+ }
+ return (rlim.rlim_cur == RLIM_INFINITY) ?
+ INT64_MAX : rlim.rlim_cur;
+#else
+ return 0;
+#endif
+}
+
+JNIEXPORT void JNICALL
+Java_org_apache_ratis_io_nativeio_NativeIO_copyFileUnbuffered0(
+JNIEnv *env, jclass clazz, jstring jsrc, jstring jdst)
+{
+#ifdef UNIX
+ THROW(env, "java/lang/UnsupportedOperationException",
+ "The function copyFileUnbuffered0 should not be used on Unix. Use FileChannel#transferTo instead.");
+#endif
+
+#ifdef WINDOWS
+ LPCWSTR src = NULL, dst = NULL;
+
+ src = (LPCWSTR) (*env)->GetStringChars(env, jsrc, NULL);
+ if (!src) goto cleanup; // exception was thrown
+ dst = (LPCWSTR) (*env)->GetStringChars(env, jdst, NULL);
+ if (!dst) goto cleanup; // exception was thrown
+ if (!CopyFileEx(src, dst, NULL, NULL, NULL, COPY_FILE_NO_BUFFERING)) {
+ throw_ioe(env, GetLastError());
+ }
+
+cleanup:
+ if (src) (*env)->ReleaseStringChars(env, jsrc, src);
+ if (dst) (*env)->ReleaseStringChars(env, jdst, dst);
+#endif
+}
+
+/**
+ * vim: sw=2: ts=2: et:
+ */
diff --git a/ratis-common/src/main/native/src/org/apache/ratis/io/nativeio/errno_enum.c b/ratis-common/src/main/native/src/org/apache/ratis/io/nativeio/errno_enum.c
new file mode 100644
index 0000000000..ff186a9ce3
--- /dev/null
+++ b/ratis-common/src/main/native/src/org/apache/ratis/io/nativeio/errno_enum.c
@@ -0,0 +1,123 @@
+/*
+ * 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.
+ */
+ #include
+ #include
+ #include
+
+#include "org_apache_ratis.h"
+
+typedef struct errno_mapping {
+ int errno_val;
+ char *errno_str;
+} errno_mapping_t;
+
+// Macro to define structs like {FOO, "FOO"} for each errno value
+#define MAPPING(x) {x, #x}
+static errno_mapping_t ERRNO_MAPPINGS[] = {
+ MAPPING(EPERM),
+ MAPPING(ENOENT),
+ MAPPING(ESRCH),
+ MAPPING(EINTR),
+ MAPPING(EIO),
+ MAPPING(ENXIO),
+ MAPPING(E2BIG),
+ MAPPING(ENOEXEC),
+ MAPPING(EBADF),
+ MAPPING(ECHILD),
+ MAPPING(EAGAIN),
+ MAPPING(ENOMEM),
+ MAPPING(EACCES),
+ MAPPING(EFAULT),
+ MAPPING(ENOTBLK),
+ MAPPING(EBUSY),
+ MAPPING(EEXIST),
+ MAPPING(EXDEV),
+ MAPPING(ENODEV),
+ MAPPING(ENOTDIR),
+ MAPPING(EISDIR),
+ MAPPING(EINVAL),
+ MAPPING(ENFILE),
+ MAPPING(EMFILE),
+ MAPPING(ENOTTY),
+ MAPPING(ETXTBSY),
+ MAPPING(EFBIG),
+ MAPPING(ENOSPC),
+ MAPPING(ESPIPE),
+ MAPPING(EROFS),
+ MAPPING(EMLINK),
+ MAPPING(EPIPE),
+ MAPPING(EDOM),
+ MAPPING(ERANGE),
+ MAPPING(ELOOP),
+ MAPPING(ENAMETOOLONG),
+ MAPPING(ENOTEMPTY),
+ MAPPING(EOVERFLOW),
+ {-1, NULL}
+};
+
+static jclass enum_class;
+static jmethodID enum_valueOf;
+static jclass errno_class;
+
+void errno_enum_init(JNIEnv *env) {
+ if (enum_class != NULL) return;
+
+ enum_class = (*env)->FindClass(env, "java/lang/Enum");
+ PASS_EXCEPTIONS(env);
+ enum_class = (*env)->NewGlobalRef(env, enum_class);
+ enum_valueOf = (*env)->GetStaticMethodID(env, enum_class,
+ "valueOf", "(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;");
+ PASS_EXCEPTIONS(env);
+
+ errno_class = (*env)->FindClass(env, "org/apache/ratis/io/nativeio/Errno");
+ PASS_EXCEPTIONS(env);
+ errno_class = (*env)->NewGlobalRef(env, errno_class);
+}
+
+void errno_enum_deinit(JNIEnv *env) {
+ if (enum_class != NULL) {
+ (*env)->DeleteGlobalRef(env, enum_class);
+ enum_class = NULL;
+ }
+ if (errno_class != NULL) {
+ (*env)->DeleteGlobalRef(env, errno_class);
+ errno_class = NULL;
+ }
+ enum_valueOf = NULL;
+}
+
+
+static char *errno_to_string(int errnum) {
+ int i;
+ for (i = 0; ERRNO_MAPPINGS[i].errno_str != NULL; i++) {
+ if (ERRNO_MAPPINGS[i].errno_val == errnum)
+ return ERRNO_MAPPINGS[i].errno_str;
+ }
+ return "UNKNOWN";
+}
+
+jobject errno_to_enum(JNIEnv *env, int errnum) {
+ char *str = errno_to_string(errnum);
+ assert(str != NULL);
+
+ jstring jstr = (*env)->NewStringUTF(env, str);
+ PASS_EXCEPTIONS_RET(env, NULL);
+
+ return (*env)->CallStaticObjectMethod(
+ env, enum_class, enum_valueOf, errno_class, jstr);
+}
diff --git a/ratis-common/src/main/native/src/org/apache/ratis/io/nativeio/errno_enum.h b/ratis-common/src/main/native/src/org/apache/ratis/io/nativeio/errno_enum.h
new file mode 100644
index 0000000000..1eee11a5f8
--- /dev/null
+++ b/ratis-common/src/main/native/src/org/apache/ratis/io/nativeio/errno_enum.h
@@ -0,0 +1,27 @@
+/*
+ * 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.
+ */
+#ifndef ERRNO_ENUM_H
+#define ERRNO_ENUM_H
+
+#include
+
+void errno_enum_init(JNIEnv *env);
+void errno_enum_deinit(JNIEnv *env);
+jobject errno_to_enum(JNIEnv *env, int errnum);
+
+#endif
diff --git a/ratis-common/src/main/native/src/org/apache/ratis/io/nativeio/file_descriptor.c b/ratis-common/src/main/native/src/org/apache/ratis/io/nativeio/file_descriptor.c
new file mode 100644
index 0000000000..4ef7308c3e
--- /dev/null
+++ b/ratis-common/src/main/native/src/org/apache/ratis/io/nativeio/file_descriptor.c
@@ -0,0 +1,115 @@
+/*
+ * 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.
+ */
+
+#include
+#include "file_descriptor.h"
+#include "org_apache_ratis.h"
+
+// class of java.io.FileDescriptor
+static jclass fd_class;
+// the internal field for the integer fd
+static jfieldID fd_descriptor;
+// the no-argument constructor
+static jmethodID fd_constructor;
+
+#ifdef WINDOWS
+// the internal field for the long handle
+static jfieldID fd_handle;
+#endif
+
+void fd_init(JNIEnv* env)
+{
+ if (fd_class != NULL) return; // already initted
+
+ fd_class = (*env)->FindClass(env, "java/io/FileDescriptor");
+ PASS_EXCEPTIONS(env);
+ fd_class = (*env)->NewGlobalRef(env, fd_class);
+
+ fd_descriptor = (*env)->GetFieldID(env, fd_class, "fd", "I");
+ PASS_EXCEPTIONS(env);
+
+#ifdef WINDOWS
+ fd_handle = (*env)->GetFieldID(env, fd_class, "handle", "J");
+ PASS_EXCEPTIONS(env);
+#endif
+
+ fd_constructor = (*env)->GetMethodID(env, fd_class, "", "()V");
+}
+
+void fd_deinit(JNIEnv *env) {
+ if (fd_class != NULL) {
+ (*env)->DeleteGlobalRef(env, fd_class);
+ fd_class = NULL;
+ }
+ fd_descriptor = NULL;
+#ifdef WINDOWS
+ fd_handle = NULL;
+#endif
+ fd_constructor = NULL;
+}
+
+#ifdef UNIX
+/*
+ * Given an instance 'obj' of java.io.FileDescriptor, return the
+ * underlying fd, or throw if unavailable
+ */
+int fd_get(JNIEnv* env, jobject obj) {
+ if (obj == NULL) {
+ THROW(env, "java/lang/NullPointerException",
+ "FileDescriptor object is null");
+ return -1;
+ }
+ return (*env)->GetIntField(env, obj, fd_descriptor);
+}
+
+/*
+ * Create a FileDescriptor object corresponding to the given int fd
+ */
+jobject fd_create(JNIEnv *env, int fd) {
+ jobject obj = (*env)->NewObject(env, fd_class, fd_constructor);
+ PASS_EXCEPTIONS_RET(env, NULL);
+
+ (*env)->SetIntField(env, obj, fd_descriptor, fd);
+ return obj;
+}
+#endif
+
+#ifdef WINDOWS
+/*
+ * Given an instance 'obj' of java.io.FileDescriptor, return the
+ * underlying fd, or throw if unavailable
+ */
+long fd_get(JNIEnv* env, jobject obj) {
+ if (obj == NULL) {
+ THROW(env, "java/lang/NullPointerException",
+ "FileDescriptor object is null");
+ return -1;
+ }
+ return (long) (*env)->GetLongField(env, obj, fd_handle);
+}
+
+/*
+ * Create a FileDescriptor object corresponding to the given int fd
+ */
+jobject fd_create(JNIEnv *env, long fd) {
+ jobject obj = (*env)->NewObject(env, fd_class, fd_constructor);
+ PASS_EXCEPTIONS_RET(env, (jobject) NULL);
+
+ (*env)->SetLongField(env, obj, fd_handle, fd);
+ return obj;
+}
+#endif
diff --git a/ratis-common/src/main/native/src/org/apache/ratis/io/nativeio/file_descriptor.h b/ratis-common/src/main/native/src/org/apache/ratis/io/nativeio/file_descriptor.h
new file mode 100644
index 0000000000..565b4e1efc
--- /dev/null
+++ b/ratis-common/src/main/native/src/org/apache/ratis/io/nativeio/file_descriptor.h
@@ -0,0 +1,36 @@
+/*
+ * 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.
+ */
+#ifndef FILE_DESCRIPTOR_H
+#define FILE_DESCRIPTOR_H
+
+#include
+#include "org_apache_ratis.h"
+
+void fd_init(JNIEnv *env);
+void fd_deinit(JNIEnv *env);
+
+#ifdef UNIX
+int fd_get(JNIEnv* env, jobject obj);
+jobject fd_create(JNIEnv *env, int fd);
+#endif
+
+#ifdef WINDOWS
+long fd_get(JNIEnv* env, jobject obj);
+jobject fd_create(JNIEnv *env, long fd);
+#endif
+
+#endif
diff --git a/ratis-common/src/main/native/src/org/apache/ratis/util/NativeCodeLoader.c b/ratis-common/src/main/native/src/org/apache/ratis/util/NativeCodeLoader.c
new file mode 100644
index 0000000000..16b8980ba6
--- /dev/null
+++ b/ratis-common/src/main/native/src/org/apache/ratis/util/NativeCodeLoader.c
@@ -0,0 +1,56 @@
+/*
+ * 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.
+ */
+
+#include "org_apache_ratis.h"
+
+#ifdef UNIX
+#include
+#include "config.h"
+#endif // UNIX
+
+#ifdef WINDOWS
+#include "winutils.h"
+#endif
+
+#include
+
+JNIEXPORT jstring JNICALL Java_org_apache_ratis_util_NativeCodeLoader_getLibraryName
+ (JNIEnv *env, jclass clazz)
+{
+#ifdef UNIX
+ Dl_info dl_info;
+ int ret = dladdr(
+ Java_org_apache_ratis_util_NativeCodeLoader_getLibraryName,
+ &dl_info);
+ return (*env)->NewStringUTF(env, ret==0 ? "Unavailable" : dl_info.dli_fname);
+#endif
+
+#ifdef WINDOWS
+ LPWSTR filename = NULL;
+ GetLibraryName(Java_org_apache_ratis_util_NativeCodeLoader_getLibraryName,
+ &filename);
+ if (filename != NULL)
+ {
+ return (*env)->NewString(env, filename, (jsize) wcslen(filename));
+ }
+ else
+ {
+ return (*env)->NewStringUTF(env, "Unavailable");
+ }
+#endif
+}
diff --git a/ratis-common/src/main/native/src/org/apache/ratis/util/NativeCrc32.c b/ratis-common/src/main/native/src/org/apache/ratis/util/NativeCrc32.c
new file mode 100644
index 0000000000..2ed9ab1860
--- /dev/null
+++ b/ratis-common/src/main/native/src/org/apache/ratis/util/NativeCrc32.c
@@ -0,0 +1,276 @@
+/*
+ * 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.
+ */
+
+#include "org_apache_ratis.h"
+#include "org_apache_ratis_util_NativeCrc32.h"
+
+#include
+#include
+#include
+#include
+
+#ifdef UNIX
+#include
+#include
+#include
+#include "config.h"
+#include "gcc_optimizations.h"
+#endif // UNIX
+
+#include "bulk_crc32.h"
+
+#define MBYTE 1048576
+#define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
+#define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
+
+static void throw_checksum_exception(JNIEnv *env,
+ uint32_t got_crc, uint32_t expected_crc,
+ jstring j_filename, jlong pos) {
+ char message[1024];
+ jstring jstr_message;
+ char *filename;
+ jclass checksum_exception_clazz;
+ jmethodID checksum_exception_ctor;
+ jthrowable obj;
+
+ // Get filename as C string, or "null" if not provided
+ if (j_filename == NULL) {
+ filename = strdup("null");
+ } else {
+ const char *c_filename = (*env)->GetStringUTFChars(env, j_filename, NULL);
+ if (c_filename == NULL) {
+ return; // OOME already thrown
+ }
+ filename = strdup(c_filename);
+ (*env)->ReleaseStringUTFChars(env, j_filename, c_filename);
+ }
+
+ // Format error message
+#ifdef WINDOWS
+ _snprintf_s(
+ message,
+ sizeof(message),
+ _TRUNCATE,
+ "Checksum error: %s at %I64d exp: %d got: %d",
+ filename, pos, expected_crc, got_crc);
+#else
+ snprintf(message, sizeof(message),
+ "Checksum error: %s at %"PRId64" exp: %"PRId32" got: %"PRId32,
+ filename, pos, expected_crc, got_crc);
+#endif // WINDOWS
+
+ if ((jstr_message = (*env)->NewStringUTF(env, message)) == NULL) {
+ goto cleanup;
+ }
+
+ // Throw exception
+ checksum_exception_clazz = (*env)->FindClass(
+ env, "org/apache/ratis/protocol/ChecksumException");
+ if (checksum_exception_clazz == NULL) {
+ goto cleanup;
+ }
+
+ checksum_exception_ctor = (*env)->GetMethodID(env,
+ checksum_exception_clazz, "",
+ "(Ljava/lang/String;J)V");
+ if (checksum_exception_ctor == NULL) {
+ goto cleanup;
+ }
+
+ obj = (jthrowable)(*env)->NewObject(env, checksum_exception_clazz,
+ checksum_exception_ctor, jstr_message, pos);
+ if (obj == NULL) goto cleanup;
+
+ (*env)->Throw(env, obj);
+
+cleanup:
+ if (filename != NULL) {
+ free(filename);
+ }
+}
+
+static int convert_java_crc_type(JNIEnv *env, jint crc_type) {
+ switch (crc_type) {
+ case org_apache_ratis_util_NativeCrc32_CHECKSUM_CRC32:
+ return CRC32_ZLIB_POLYNOMIAL;
+ case org_apache_ratis_util_NativeCrc32_CHECKSUM_CRC32C:
+ return CRC32C_POLYNOMIAL;
+ default:
+ THROW(env, "java/lang/IllegalArgumentException",
+ "Invalid checksum type");
+ return -1;
+ }
+}
+
+JNIEXPORT void JNICALL Java_org_apache_ratis_util_NativeCrc32_nativeComputeChunkedSums
+ (JNIEnv *env, jclass clazz,
+ jint bytes_per_checksum, jint j_crc_type,
+ jobject j_sums, jint sums_offset,
+ jobject j_data, jint data_offset, jint data_len,
+ jstring j_filename, jlong base_pos, jboolean verify)
+{
+ uint8_t *sums_addr;
+ uint8_t *data_addr;
+ uint32_t *sums;
+ uint8_t *data;
+ int crc_type;
+ crc32_error_t error_data;
+ int ret;
+
+ if (unlikely(!j_sums || !j_data)) {
+ THROW(env, "java/lang/NullPointerException",
+ "input ByteBuffers must not be null");
+ return;
+ }
+
+ // Convert direct byte buffers to C pointers
+ sums_addr = (*env)->GetDirectBufferAddress(env, j_sums);
+ data_addr = (*env)->GetDirectBufferAddress(env, j_data);
+
+ if (unlikely(!sums_addr || !data_addr)) {
+ THROW(env, "java/lang/IllegalArgumentException",
+ "input ByteBuffers must be direct buffers");
+ return;
+ }
+ if (unlikely(sums_offset < 0 || data_offset < 0 || data_len < 0)) {
+ THROW(env, "java/lang/IllegalArgumentException",
+ "bad offsets or lengths");
+ return;
+ }
+ if (unlikely(bytes_per_checksum) <= 0) {
+ THROW(env, "java/lang/IllegalArgumentException",
+ "invalid bytes_per_checksum");
+ return;
+ }
+
+ sums = (uint32_t *)(sums_addr + sums_offset);
+ data = data_addr + data_offset;
+
+ // Convert to correct internal C constant for CRC type
+ crc_type = convert_java_crc_type(env, j_crc_type);
+ if (crc_type == -1) return; // exception already thrown
+
+ // Setup complete. Actually verify checksums.
+ ret = bulk_crc(data, data_len, sums, crc_type,
+ bytes_per_checksum, verify ? &error_data : NULL);
+ if (likely((verify && ret == CHECKSUMS_VALID) || (!verify && ret == 0))) {
+ return;
+ } else if (unlikely(verify && ret == INVALID_CHECKSUM_DETECTED)) {
+ long pos = base_pos + (error_data.bad_data - data);
+ throw_checksum_exception(
+ env, error_data.got_crc, error_data.expected_crc,
+ j_filename, pos);
+ } else {
+ THROW(env, "java/lang/AssertionError",
+ "Bad response code from native bulk_crc");
+ }
+}
+
+JNIEXPORT void JNICALL Java_org_apache_ratis_util_NativeCrc32_nativeVerifyChunkedSums
+ (JNIEnv *env, jclass clazz,
+ jint bytes_per_checksum, jint j_crc_type,
+ jobject j_sums, jint sums_offset,
+ jobject j_data, jint data_offset, jint data_len,
+ jstring j_filename, jlong base_pos)
+{
+ Java_org_apache_ratis_util_NativeCrc32_nativeComputeChunkedSums(env, clazz,
+ bytes_per_checksum, j_crc_type, j_sums, sums_offset, j_data, data_offset,
+ data_len, j_filename, base_pos, JNI_TRUE);
+}
+
+JNIEXPORT void JNICALL Java_org_apache_ratis_util_NativeCrc32_nativeComputeChunkedSumsByteArray
+ (JNIEnv *env, jclass clazz,
+ jint bytes_per_checksum, jint j_crc_type,
+ jarray j_sums, jint sums_offset,
+ jarray j_data, jint data_offset, jint data_len,
+ jstring j_filename, jlong base_pos, jboolean verify)
+{
+ uint8_t *sums_addr;
+ uint8_t *data_addr;
+ uint32_t *sums;
+ uint8_t *data;
+ int crc_type;
+ crc32_error_t error_data;
+ int ret;
+ int numChecksumsPerIter;
+ int checksumNum;
+
+ if (unlikely(!j_sums || !j_data)) {
+ THROW(env, "java/lang/NullPointerException",
+ "input byte arrays must not be null");
+ return;
+ }
+ if (unlikely(sums_offset < 0 || data_offset < 0 || data_len < 0)) {
+ THROW(env, "java/lang/IllegalArgumentException",
+ "bad offsets or lengths");
+ return;
+ }
+ if (unlikely(bytes_per_checksum) <= 0) {
+ THROW(env, "java/lang/IllegalArgumentException",
+ "invalid bytes_per_checksum");
+ return;
+ }
+
+ // Convert to correct internal C constant for CRC type
+ crc_type = convert_java_crc_type(env, j_crc_type);
+ if (crc_type == -1) return; // exception already thrown
+
+ numChecksumsPerIter = MAX(1, MBYTE / bytes_per_checksum);
+ checksumNum = 0;
+ while (checksumNum * bytes_per_checksum < data_len) {
+ // Convert byte arrays to C pointers
+ sums_addr = (*env)->GetPrimitiveArrayCritical(env, j_sums, NULL);
+ data_addr = (*env)->GetPrimitiveArrayCritical(env, j_data, NULL);
+
+ if (unlikely(!sums_addr || !data_addr)) {
+ if (data_addr) (*env)->ReleasePrimitiveArrayCritical(env, j_data, data_addr, 0);
+ if (sums_addr) (*env)->ReleasePrimitiveArrayCritical(env, j_sums, sums_addr, 0);
+ THROW(env, "java/lang/OutOfMemoryError",
+ "not enough memory for byte arrays in JNI code");
+ return;
+ }
+
+ sums = (uint32_t *)(sums_addr + sums_offset) + checksumNum;
+ data = data_addr + data_offset + checksumNum * bytes_per_checksum;
+
+ // Setup complete. Actually verify checksums.
+ ret = bulk_crc(data, MIN(numChecksumsPerIter * bytes_per_checksum,
+ data_len - checksumNum * bytes_per_checksum),
+ sums, crc_type, bytes_per_checksum, verify ? &error_data : NULL);
+ (*env)->ReleasePrimitiveArrayCritical(env, j_data, data_addr, 0);
+ (*env)->ReleasePrimitiveArrayCritical(env, j_sums, sums_addr, 0);
+ if (unlikely(verify && ret == INVALID_CHECKSUM_DETECTED)) {
+ long pos = base_pos + (error_data.bad_data - data) + checksumNum *
+ bytes_per_checksum;
+ throw_checksum_exception(
+ env, error_data.got_crc, error_data.expected_crc,
+ j_filename, pos);
+ return;
+ } else if (unlikely((verify && ret != CHECKSUMS_VALID) || (!verify && ret != 0))) {
+ THROW(env, "java/lang/AssertionError",
+ "Bad response code from native bulk_crc");
+ return;
+ }
+ checksumNum += numChecksumsPerIter;
+ }
+
+}
+
+/**
+ * vim: sw=2: ts=2: et:
+ */
diff --git a/ratis-common/src/main/native/src/org/apache/ratis/util/bulk_crc32.c b/ratis-common/src/main/native/src/org/apache/ratis/util/bulk_crc32.c
new file mode 100644
index 0000000000..5620487871
--- /dev/null
+++ b/ratis-common/src/main/native/src/org/apache/ratis/util/bulk_crc32.c
@@ -0,0 +1,244 @@
+/*
+ * 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.
+ *
+ * Portions of this file are from http://www.evanjones.ca/crc32c.html under
+ * the BSD license:
+ * Copyright 2008,2009,2010 Massachusetts Institute of Technology.
+ * All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+
+#include "org_apache_ratis.h"
+
+#include
+#include
+#include
+
+#ifdef UNIX
+#include
+#include
+#endif // UNIX
+
+#include "crc32_zlib_polynomial_tables.h"
+#include "crc32c_tables.h"
+#include "bulk_crc32.h"
+#include "gcc_optimizations.h"
+
+#define CRC_INITIAL_VAL 0xffffffff
+
+static uint32_t crc_val(uint32_t crc);
+
+typedef void (*crc_pipelined_func_t)(uint32_t *, uint32_t *, uint32_t *, const uint8_t *, size_t, int);
+
+// The software versions of pipelined crc
+static void pipelined_crc32c_sb8(uint32_t *crc1, uint32_t *crc2, uint32_t *crc3,
+ const uint8_t *p_buf, size_t block_size, int num_blocks);
+static void pipelined_crc32_zlib_sb8(uint32_t *crc1, uint32_t *crc2, uint32_t *crc3,
+ const uint8_t *p_buf, size_t block_size, int num_blocks);
+
+// Satically initialise the function pointers to the software versions
+// If a HW implementation is available they will subsequently be initialised in the dynamic
+// initialisers to point to the HW routines.
+crc_pipelined_func_t pipelined_crc32c_func = pipelined_crc32c_sb8;
+crc_pipelined_func_t pipelined_crc32_zlib_func = pipelined_crc32_zlib_sb8;
+
+static inline int store_or_verify(uint32_t *sums, uint32_t crc,
+ int is_verify) {
+ if (!is_verify) {
+ *sums = crc;
+ return 1;
+ } else {
+ return crc == *sums;
+ }
+}
+
+int bulk_crc(const uint8_t *data, size_t data_len,
+ uint32_t *sums, int checksum_type,
+ int bytes_per_checksum,
+ crc32_error_t *error_info) {
+
+ int is_verify = error_info != NULL;
+
+ uint32_t crc1, crc2, crc3;
+ int n_blocks = data_len / bytes_per_checksum;
+ int remainder = data_len % bytes_per_checksum;
+ uint32_t crc;
+ crc_pipelined_func_t crc_pipelined_func;
+ switch (checksum_type) {
+ case CRC32_ZLIB_POLYNOMIAL:
+ crc_pipelined_func = pipelined_crc32_zlib_func;
+ break;
+ case CRC32C_POLYNOMIAL:
+ crc_pipelined_func = pipelined_crc32c_func;
+ break;
+ default:
+ return is_verify ? INVALID_CHECKSUM_TYPE : -EINVAL;
+ }
+
+ /* Process three blocks at a time */
+ while (likely(n_blocks >= 3)) {
+ crc1 = crc2 = crc3 = CRC_INITIAL_VAL;
+ crc_pipelined_func(&crc1, &crc2, &crc3, data, bytes_per_checksum, 3);
+
+ if (unlikely(!store_or_verify(sums, (crc = ntohl(crc_val(crc1))), is_verify)))
+ goto return_crc_error;
+ sums++;
+ data += bytes_per_checksum;
+ if (unlikely(!store_or_verify(sums, (crc = ntohl(crc_val(crc2))), is_verify)))
+ goto return_crc_error;
+ sums++;
+ data += bytes_per_checksum;
+ if (unlikely(!store_or_verify(sums, (crc = ntohl(crc_val(crc3))), is_verify)))
+ goto return_crc_error;
+ sums++;
+ data += bytes_per_checksum;
+ n_blocks -= 3;
+ }
+
+ /* One or two blocks */
+ if (n_blocks) {
+ crc1 = crc2 = crc3 = CRC_INITIAL_VAL;
+ crc_pipelined_func(&crc1, &crc2, &crc3, data, bytes_per_checksum, n_blocks);
+
+ if (unlikely(!store_or_verify(sums, (crc = ntohl(crc_val(crc1))), is_verify)))
+ goto return_crc_error;
+ data += bytes_per_checksum;
+ sums++;
+ if (n_blocks == 2) {
+ if (unlikely(!store_or_verify(sums, (crc = ntohl(crc_val(crc2))), is_verify)))
+ goto return_crc_error;
+ sums++;
+ data += bytes_per_checksum;
+ }
+ }
+
+ /* For something smaller than a block */
+ if (remainder) {
+ crc1 = crc2 = crc3 = CRC_INITIAL_VAL;
+ crc_pipelined_func(&crc1, &crc2, &crc3, data, remainder, 1);
+
+ if (unlikely(!store_or_verify(sums, (crc = ntohl(crc_val(crc1))), is_verify)))
+ goto return_crc_error;
+ }
+ return is_verify ? CHECKSUMS_VALID : 0;
+
+return_crc_error:
+ if (error_info != NULL) {
+ error_info->got_crc = crc;
+ error_info->expected_crc = *sums;
+ error_info->bad_data = data;
+ }
+ return INVALID_CHECKSUM_DETECTED;
+}
+
+/**
+ * Extract the final result of a CRC
+ */
+static uint32_t crc_val(uint32_t crc) {
+ return ~crc;
+}
+
+/**
+ * Computes the CRC32c checksum for the specified buffer using the slicing by 8
+ * algorithm over 64 bit quantities.
+ */
+static uint32_t crc32c_sb8(uint32_t crc, const uint8_t *buf, size_t length) {
+ uint32_t running_length = ((length)/8)*8;
+ uint32_t end_bytes = length - running_length;
+ int li;
+ for (li=0; li < running_length/8; li++) {
+ uint32_t term1;
+ uint32_t term2;
+ crc ^= *(uint32_t *)buf;
+ buf += 4;
+ term1 = CRC32C_T8_7[crc & 0x000000FF] ^
+ CRC32C_T8_6[(crc >> 8) & 0x000000FF];
+ term2 = crc >> 16;
+ crc = term1 ^
+ CRC32C_T8_5[term2 & 0x000000FF] ^
+ CRC32C_T8_4[(term2 >> 8) & 0x000000FF];
+ term1 = CRC32C_T8_3[(*(uint32_t *)buf) & 0x000000FF] ^
+ CRC32C_T8_2[((*(uint32_t *)buf) >> 8) & 0x000000FF];
+
+ term2 = (*(uint32_t *)buf) >> 16;
+ crc = crc ^
+ term1 ^
+ CRC32C_T8_1[term2 & 0x000000FF] ^
+ CRC32C_T8_0[(term2 >> 8) & 0x000000FF];
+ buf += 4;
+ }
+ for (li=0; li < end_bytes; li++) {
+ crc = CRC32C_T8_0[(crc ^ *buf++) & 0x000000FF] ^ (crc >> 8);
+ }
+ return crc;
+}
+
+static void pipelined_crc32c_sb8(uint32_t *crc1, uint32_t *crc2, uint32_t *crc3,
+ const uint8_t *p_buf, size_t block_size, int num_blocks) {
+ assert(num_blocks >= 1 && num_blocks <=3 && "invalid num_blocks");
+ *crc1 = crc32c_sb8(*crc1, p_buf, block_size);
+ if (num_blocks >= 2)
+ *crc2 = crc32c_sb8(*crc2, p_buf+block_size, block_size);
+ if (num_blocks >= 3)
+ *crc3 = crc32c_sb8(*crc3, p_buf+2*block_size, block_size);
+}
+
+/**
+ * Update a CRC using the "zlib" polynomial -- what Raft calls CHECKSUM_CRC32
+ * using slicing-by-8
+ */
+static uint32_t crc32_zlib_sb8(
+ uint32_t crc, const uint8_t *buf, size_t length) {
+ uint32_t running_length = ((length)/8)*8;
+ uint32_t end_bytes = length - running_length;
+ int li;
+ for (li=0; li < running_length/8; li++) {
+ uint32_t term1;
+ uint32_t term2;
+ crc ^= *(uint32_t *)buf;
+ buf += 4;
+ term1 = CRC32_T8_7[crc & 0x000000FF] ^
+ CRC32_T8_6[(crc >> 8) & 0x000000FF];
+ term2 = crc >> 16;
+ crc = term1 ^
+ CRC32_T8_5[term2 & 0x000000FF] ^
+ CRC32_T8_4[(term2 >> 8) & 0x000000FF];
+ term1 = CRC32_T8_3[(*(uint32_t *)buf) & 0x000000FF] ^
+ CRC32_T8_2[((*(uint32_t *)buf) >> 8) & 0x000000FF];
+
+ term2 = (*(uint32_t *)buf) >> 16;
+ crc = crc ^
+ term1 ^
+ CRC32_T8_1[term2 & 0x000000FF] ^
+ CRC32_T8_0[(term2 >> 8) & 0x000000FF];
+ buf += 4;
+ }
+ for (li=0; li < end_bytes; li++) {
+ crc = CRC32_T8_0[(crc ^ *buf++) & 0x000000FF] ^ (crc >> 8);
+ }
+ return crc;
+}
+
+static void pipelined_crc32_zlib_sb8(uint32_t *crc1, uint32_t *crc2, uint32_t *crc3,
+ const uint8_t *p_buf, size_t block_size, int num_blocks) {
+ assert(num_blocks >= 1 && num_blocks <=3 && "invalid num_blocks");
+ *crc1 = crc32_zlib_sb8(*crc1, p_buf, block_size);
+ if (num_blocks >= 2)
+ *crc2 = crc32_zlib_sb8(*crc2, p_buf+block_size, block_size);
+ if (num_blocks >= 3)
+ *crc3 = crc32_zlib_sb8(*crc3, p_buf+2*block_size, block_size);
+}
diff --git a/ratis-common/src/main/native/src/org/apache/ratis/util/bulk_crc32.h b/ratis-common/src/main/native/src/org/apache/ratis/util/bulk_crc32.h
new file mode 100644
index 0000000000..b38a65acc6
--- /dev/null
+++ b/ratis-common/src/main/native/src/org/apache/ratis/util/bulk_crc32.h
@@ -0,0 +1,73 @@
+/*
+ * 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.
+ */
+#ifndef BULK_CRC32_H_INCLUDED
+#define BULK_CRC32_H_INCLUDED
+
+#include
+
+#ifdef UNIX
+#include /* for size_t */
+#endif // UNIX
+
+// Constants for different CRC algorithms
+#define CRC32C_POLYNOMIAL 1
+#define CRC32_ZLIB_POLYNOMIAL 2
+
+// Return codes for bulk_verify_crc
+#define CHECKSUMS_VALID 0
+#define INVALID_CHECKSUM_DETECTED -1
+#define INVALID_CHECKSUM_TYPE -2
+
+// Return type for bulk verification when verification fails
+typedef struct crc32_error {
+ uint32_t got_crc;
+ uint32_t expected_crc;
+ const uint8_t *bad_data; // pointer to start of data chunk with error
+} crc32_error_t;
+
+
+/**
+ * Either calculates checksums for or verifies a buffer of data.
+ * Checksums performed in chunks of bytes_per_checksum bytes. The checksums
+ * are each 32 bits and are stored in sequential indexes of the 'sums' array.
+ * Verification is done (sums is assumed to already contain the checksums)
+ * if error_info is non-null; otherwise calculation is done and checksums
+ * are stored into sums.
+ *
+ * @param data The data to checksum
+ * @param dataLen Length of the data buffer
+ * @param sums (out param) buffer to write checksums into or
+ * where checksums are already stored.
+ * It must contain at least
+ * ((dataLen - 1) / bytes_per_checksum + 1) * 4 bytes.
+ * @param checksum_type One of the CRC32 algorithm constants defined
+ * above
+ * @param bytes_per_checksum How many bytes of data to process per checksum.
+ * @param error_info If non-NULL, verification will be performed and
+ * it will be filled in if an error
+ * is detected. Otherwise calculation is performed.
+ *
+ * @return 0 for success, non-zero for an error, result codes
+ * for verification are defined above
+ */
+extern int bulk_crc(const uint8_t *data, size_t data_len,
+ uint32_t *sums, int checksum_type,
+ int bytes_per_checksum,
+ crc32_error_t *error_info);
+
+#endif
diff --git a/ratis-common/src/main/native/src/org/apache/ratis/util/bulk_crc32_aarch64.c b/ratis-common/src/main/native/src/org/apache/ratis/util/bulk_crc32_aarch64.c
new file mode 100644
index 0000000000..ab4690bcdf
--- /dev/null
+++ b/ratis-common/src/main/native/src/org/apache/ratis/util/bulk_crc32_aarch64.c
@@ -0,0 +1,362 @@
+/*
+ * 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.
+ */
+
+#include
+#include // for size_t
+
+#include "bulk_crc32.h"
+#include "gcc_optimizations.h"
+
+/**
+ * Hardware-accelerated CRC32 calculation using the 64-bit instructions.
+ * 2 variants:-
+ * pipelined_crc32c uses the Castagnoli polynomial 0x1EDC6F41
+ * pipelined_crc32_zlib uses the Zlib polynomial 0x04C11DB7
+ */
+
+// gcc doesn't know how to vectorize a 128 bit load, so use the following to tell it
+#define LDP(x,y,p) asm("ldp %x[a], %x[b], [%x[c]], #16" : [a]"=r"(x),[b]"=r"(y),[c]"+r"(p))
+
+#define CRC32CX(crc,value) asm("crc32cx %w[c], %w[c], %x[v]" : [c]"+r"(*&crc) : [v]"r"(+value))
+#define CRC32CW(crc,value) asm("crc32cw %w[c], %w[c], %w[v]" : [c]"+r"(*&crc) : [v]"r"(+value))
+#define CRC32CH(crc,value) asm("crc32ch %w[c], %w[c], %w[v]" : [c]"+r"(*&crc) : [v]"r"(+value))
+#define CRC32CB(crc,value) asm("crc32cb %w[c], %w[c], %w[v]" : [c]"+r"(*&crc) : [v]"r"(+value))
+
+#define CRC32ZX(crc,value) asm("crc32x %w[c], %w[c], %x[v]" : [c]"+r"(crc) : [v]"r"(value))
+#define CRC32ZW(crc,value) asm("crc32w %w[c], %w[c], %w[v]" : [c]"+r"(crc) : [v]"r"(value))
+#define CRC32ZH(crc,value) asm("crc32h %w[c], %w[c], %w[v]" : [c]"+r"(crc) : [v]"r"(value))
+#define CRC32ZB(crc,value) asm("crc32b %w[c], %w[c], %w[v]" : [c]"+r"(crc) : [v]"r"(value))
+
+/**
+ * Pipelined version of hardware-accelerated CRC32 calculation using
+ * the 64 bit crc32 instructions.
+ * One crc32 instruction takes three cycles, but two more with no data
+ * dependency can be in the pipeline to achieve something close to single
+ * instruction/cycle. Here we feed three blocks in RR.
+ *
+ * 2 variants:-
+ * pipelined_crc32c uses the Castagnoli polynomial 0x1EDC6F41
+ * pipelined_crc32_zlib uses the Zlib polynomial 0x04C11DB7
+ *
+ * crc1, crc2, crc3 : Store initial checksum for each block before
+ * calling. When it returns, updated checksums are stored.
+ * p_buf : The base address of the data buffer. The buffer should be
+ * at least as big as block_size * num_blocks.
+ * block_size : The size of each block in bytes.
+ * num_blocks : The number of blocks to work on. Min = 1, Max = 3
+ */
+static void pipelined_crc32c(uint32_t *crc1, uint32_t *crc2, uint32_t *crc3, const uint8_t *p_buf1, size_t block_size, int num_blocks) {
+ uint64_t c1 = *crc1;
+ uint64_t c2 = *crc2;
+ uint64_t c3 = *crc3;
+ const uint8_t *p_buf2 = p_buf1 + block_size;
+ const uint8_t *p_buf3 = p_buf1 + block_size * 2;
+ uint64_t x1, y1, x2, y2, x3, y3;
+ long len = block_size;
+
+ /* We do switch here because the loop has to be tight in order
+ * to fill the pipeline. Any other statement inside the loop
+ * or inbetween crc32 instruction can slow things down.
+ *
+ * Do verify that this code generates the expected assembler
+ * by disassembling test_bulk_crc32
+ */
+
+ asm(".cpu generic+crc"); // Allow crc instructions in asm
+ switch (num_blocks) {
+ case 3:
+ /* Do three blocks */
+ while ((len -= 2*sizeof(uint64_t)) >= 0) {
+ LDP(x1,y1,p_buf1);
+ LDP(x2,y2,p_buf2);
+ LDP(x3,y3,p_buf3);
+ CRC32CX(c1, x1);
+ CRC32CX(c2, x2);
+ CRC32CX(c3, x3);
+ CRC32CX(c1, y1);
+ CRC32CX(c2, y2);
+ CRC32CX(c3, y3);
+ }
+
+ if (unlikely(len & sizeof(uint64_t))) {
+ x1 = *(uint64_t*)p_buf1; p_buf1 += sizeof(uint64_t);
+ x2 = *(uint64_t*)p_buf2; p_buf2 += sizeof(uint64_t);
+ x3 = *(uint64_t*)p_buf3; p_buf3 += sizeof(uint64_t);
+ CRC32CX(c1, x1);
+ CRC32CX(c2, x2);
+ CRC32CX(c3, x3);
+ }
+ if (unlikely(len & sizeof(uint32_t))) {
+ x1 = *(uint32_t*)p_buf1; p_buf1 += sizeof(uint32_t);
+ x2 = *(uint32_t*)p_buf2; p_buf2 += sizeof(uint32_t);
+ x3 = *(uint32_t*)p_buf3; p_buf3 += sizeof(uint32_t);
+ CRC32CW(c1, x1);
+ CRC32CW(c2, x2);
+ CRC32CW(c3, x3);
+ }
+ if (unlikely(len & sizeof(uint16_t))) {
+ x1 = *(uint16_t*)p_buf1; p_buf1 += sizeof(uint16_t);
+ x2 = *(uint16_t*)p_buf2; p_buf2 += sizeof(uint16_t);
+ x3 = *(uint16_t*)p_buf3; p_buf3 += sizeof(uint16_t);
+ CRC32CH(c1, x1);
+ CRC32CH(c2, x2);
+ CRC32CH(c3, x3);
+ }
+ if (unlikely(len & sizeof(uint8_t))) {
+ x1 = *p_buf1;
+ x2 = *p_buf2;
+ x3 = *p_buf3;
+ CRC32CB(c1, x1);
+ CRC32CB(c2, x2);
+ CRC32CB(c3, x3);
+ }
+ break;
+ case 2:
+ /* Do two blocks */
+ while ((len -= 2*sizeof(uint64_t)) >= 0) {
+ LDP(x1,y1,p_buf1);
+ LDP(x2,y2,p_buf2);
+ CRC32CX(c1, x1);
+ CRC32CX(c2, x2);
+ CRC32CX(c1, y1);
+ CRC32CX(c2, y2);
+ }
+
+ if (unlikely(len & sizeof(uint64_t))) {
+ x1 = *(uint64_t*)p_buf1; p_buf1 += sizeof(uint64_t);
+ x2 = *(uint64_t*)p_buf2; p_buf2 += sizeof(uint64_t);
+ CRC32CX(c1, x1);
+ CRC32CX(c2, x2);
+ }
+ if (unlikely(len & sizeof(uint32_t))) {
+ x1 = *(uint32_t*)p_buf1; p_buf1 += sizeof(uint32_t);
+ x2 = *(uint32_t*)p_buf2; p_buf2 += sizeof(uint32_t);
+ CRC32CW(c1, x1);
+ CRC32CW(c2, x2);
+ }
+ if (unlikely(len & sizeof(uint16_t))) {
+ x1 = *(uint16_t*)p_buf1; p_buf1 += sizeof(uint16_t);
+ x2 = *(uint16_t*)p_buf2; p_buf2 += sizeof(uint16_t);
+ CRC32CH(c1, x1);
+ CRC32CH(c2, x2);
+ }
+ if (unlikely(len & sizeof(uint8_t))) {
+ x1 = *p_buf1;
+ x2 = *p_buf2;
+ CRC32CB(c1, x1);
+ CRC32CB(c2, x2);
+ }
+ break;
+ case 1:
+ /* single block */
+ while ((len -= 2*sizeof(uint64_t)) >= 0) {
+ LDP(x1,y1,p_buf1);
+ CRC32CX(c1, x1);
+ CRC32CX(c1, y1);
+ }
+
+ if (unlikely(len & sizeof(uint64_t))) {
+ x1 = *(uint64_t*)p_buf1; p_buf1 += sizeof(uint64_t);
+ CRC32CX(c1, x1);
+ }
+ if (unlikely(len & sizeof(uint32_t))) {
+ x1 = *(uint32_t*)p_buf1; p_buf1 += sizeof(uint32_t);
+ CRC32CW(c1, x1);
+ }
+ if (unlikely(len & sizeof(uint16_t))) {
+ x1 = *(uint16_t*)p_buf1; p_buf1 += sizeof(uint16_t);
+ CRC32CH(c1, x1);
+ }
+ if (unlikely(len & sizeof(uint8_t))) {
+ x1 = *p_buf1;
+ CRC32CB(c1, x1);
+ }
+ break;
+ case 0:
+ return;
+ default:
+ assert(0 && "BUG: Invalid number of checksum blocks");
+ }
+
+ *crc1 = c1;
+ *crc2 = c2;
+ *crc3 = c3;
+ return;
+}
+
+static void pipelined_crc32_zlib(uint32_t *crc1, uint32_t *crc2, uint32_t *crc3, const uint8_t *p_buf1, size_t block_size, int num_blocks) {
+ uint64_t c1 = *crc1;
+ uint64_t c2 = *crc2;
+ uint64_t c3 = *crc3;
+ const uint8_t *p_buf2 = p_buf1 + block_size;
+ const uint8_t *p_buf3 = p_buf1 + block_size * 2;
+ uint64_t x1, y1, x2, y2, x3, y3;
+ long len = block_size;
+
+ /* We do switch here because the loop has to be tight in order
+ * to fill the pipeline. Any other statement inside the loop
+ * or inbetween crc32 instruction can slow things down.
+ *
+ * Do verify that this code generates the expected assembler
+ * by disassembling test_bulk_crc32
+ */
+
+ asm(".cpu generic+crc"); // Allow crc instructions in asm
+ switch (num_blocks) {
+ case 3:
+ /* Do three blocks */
+ while ((len -= 2*sizeof(uint64_t)) >= 0) {
+ LDP(x1,y1,p_buf1);
+ LDP(x2,y2,p_buf2);
+ LDP(x3,y3,p_buf3);
+ CRC32ZX(c1, x1);
+ CRC32ZX(c2, x2);
+ CRC32ZX(c3, x3);
+ CRC32ZX(c1, y1);
+ CRC32ZX(c2, y2);
+ CRC32ZX(c3, y3);
+ }
+
+ if (unlikely(len & sizeof(uint64_t))) {
+ x1 = *(uint64_t*)p_buf1; p_buf1 += sizeof(uint64_t);
+ x2 = *(uint64_t*)p_buf2; p_buf2 += sizeof(uint64_t);
+ x3 = *(uint64_t*)p_buf3; p_buf3 += sizeof(uint64_t);
+ CRC32ZX(c1, x1);
+ CRC32ZX(c2, x2);
+ CRC32ZX(c3, x3);
+ }
+ if (unlikely(len & sizeof(uint32_t))) {
+ x1 = *(uint32_t*)p_buf1; p_buf1 += sizeof(uint32_t);
+ x2 = *(uint32_t*)p_buf2; p_buf2 += sizeof(uint32_t);
+ x3 = *(uint32_t*)p_buf3; p_buf3 += sizeof(uint32_t);
+ CRC32ZW(c1, x1);
+ CRC32ZW(c2, x2);
+ CRC32ZW(c3, x3);
+ }
+ if (unlikely(len & sizeof(uint16_t))) {
+ x1 = *(uint16_t*)p_buf1; p_buf1 += sizeof(uint16_t);
+ x2 = *(uint16_t*)p_buf2; p_buf2 += sizeof(uint16_t);
+ x3 = *(uint16_t*)p_buf3; p_buf3 += sizeof(uint16_t);
+ CRC32ZH(c1, x1);
+ CRC32ZH(c2, x2);
+ CRC32ZH(c3, x3);
+ }
+ if (unlikely(len & sizeof(uint8_t))) {
+ x1 = *p_buf1;
+ x2 = *p_buf2;
+ x3 = *p_buf3;
+ CRC32ZB(c1, x1);
+ CRC32ZB(c2, x2);
+ CRC32ZB(c3, x3);
+ }
+ break;
+ case 2:
+ /* Do two blocks */
+ while ((len -= 2*sizeof(uint64_t)) >= 0) {
+ LDP(x1,y1,p_buf1);
+ LDP(x2,y2,p_buf2);
+ CRC32ZX(c1, x1);
+ CRC32ZX(c2, x2);
+ CRC32ZX(c1, y1);
+ CRC32ZX(c2, y2);
+ }
+
+ if (unlikely(len & sizeof(uint64_t))) {
+ x1 = *(uint64_t*)p_buf1; p_buf1 += sizeof(uint64_t);
+ x2 = *(uint64_t*)p_buf2; p_buf2 += sizeof(uint64_t);
+ CRC32ZX(c1, x1);
+ CRC32ZX(c2, x2);
+ }
+ if (unlikely(len & sizeof(uint32_t))) {
+ x1 = *(uint32_t*)p_buf1; p_buf1 += sizeof(uint32_t);
+ x2 = *(uint32_t*)p_buf2; p_buf2 += sizeof(uint32_t);
+ CRC32ZW(c1, x1);
+ CRC32ZW(c2, x2);
+ }
+ if (unlikely(len & sizeof(uint16_t))) {
+ x1 = *(uint16_t*)p_buf1; p_buf1 += sizeof(uint16_t);
+ x2 = *(uint16_t*)p_buf2; p_buf2 += sizeof(uint16_t);
+ CRC32ZH(c1, x1);
+ CRC32ZH(c2, x2);
+ }
+ if (unlikely(len & sizeof(uint8_t))) {
+ x1 = *p_buf1;
+ x2 = *p_buf2;
+ CRC32ZB(c1, x1);
+ CRC32ZB(c2, x2);
+ }
+ break;
+ case 1:
+ /* single block */
+ while ((len -= 2*sizeof(uint64_t)) >= 0) {
+ LDP(x1,y1,p_buf1);
+ CRC32ZX(c1, x1);
+ CRC32ZX(c1, y1);
+ }
+
+ if (unlikely(len & sizeof(uint64_t))) {
+ x1 = *(uint64_t*)p_buf1; p_buf1 += sizeof(uint64_t);
+ CRC32ZX(c1, x1);
+ }
+ if (unlikely(len & sizeof(uint32_t))) {
+ x1 = *(uint32_t*)p_buf1; p_buf1 += sizeof(uint32_t);
+ CRC32ZW(c1, x1);
+ }
+ if (unlikely(len & sizeof(uint16_t))) {
+ x1 = *(uint16_t*)p_buf1; p_buf1 += sizeof(uint16_t);
+ CRC32ZH(c1, x1);
+ }
+ if (unlikely(len & sizeof(uint8_t))) {
+ x1 = *p_buf1;
+ CRC32ZB(c1, x1);
+ }
+ break;
+ case 0:
+ return;
+ default:
+ assert(0 && "BUG: Invalid number of checksum blocks");
+ }
+
+ *crc1 = c1;
+ *crc2 = c2;
+ *crc3 = c3;
+ return;
+}
+
+typedef void (*crc_pipelined_func_t)(uint32_t *, uint32_t *, uint32_t *, const uint8_t *, size_t, int);
+extern crc_pipelined_func_t pipelined_crc32c_func;
+extern crc_pipelined_func_t pipelined_crc32_zlib_func;
+
+#include
+#include
+
+#ifndef HWCAP_CRC32
+#define HWCAP_CRC32 (1 << 7)
+#endif
+
+/**
+ * On library load, determine what sort of crc we are going to do
+ * and set crc function pointers appropriately.
+ */
+void __attribute__ ((constructor)) init_cpu_support_flag(void) {
+ unsigned long auxv = getauxval(AT_HWCAP);
+ if (auxv & HWCAP_CRC32) {
+ pipelined_crc32c_func = pipelined_crc32c;
+ pipelined_crc32_zlib_func = pipelined_crc32_zlib;
+ }
+}
diff --git a/ratis-common/src/main/native/src/org/apache/ratis/util/bulk_crc32_x86.c b/ratis-common/src/main/native/src/org/apache/ratis/util/bulk_crc32_x86.c
new file mode 100644
index 0000000000..290b8a6199
--- /dev/null
+++ b/ratis-common/src/main/native/src/org/apache/ratis/util/bulk_crc32_x86.c
@@ -0,0 +1,345 @@
+/*
+ * 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.
+ *
+ * Portions of this file are from http://www.evanjones.ca/crc32c.html under
+ * the BSD license:
+ * Copyright 2008,2009,2010 Massachusetts Institute of Technology.
+ * All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+
+#include
+#include // for size_t
+
+#include "bulk_crc32.h"
+#include "gcc_optimizations.h"
+#include "gcc_optimizations.h"
+
+///////////////////////////////////////////////////////////////////////////
+// Begin code for SSE4.2 specific hardware support of CRC32C
+///////////////////////////////////////////////////////////////////////////
+
+# define SSE42_FEATURE_BIT (1 << 20)
+# define CPUID_FEATURES 1
+/**
+ * Call the cpuid instruction to determine CPU feature flags.
+ */
+static uint32_t cpuid(uint32_t eax_in) {
+ uint32_t eax, ebx, ecx, edx;
+# if defined(__PIC__) && !defined(__LP64__)
+// 32-bit PIC code uses the ebx register for the base offset --
+// have to save and restore it on the stack
+ asm("pushl %%ebx\n\t"
+ "cpuid\n\t"
+ "movl %%ebx, %[ebx]\n\t"
+ "popl %%ebx" : "=a" (eax), [ebx] "=r"(ebx), "=c"(ecx), "=d"(edx) : "a" (eax_in)
+ : "cc");
+# else
+ asm("cpuid" : "=a" (eax), "=b"(ebx), "=c"(ecx), "=d"(edx) : "a"(eax_in)
+ : "cc");
+# endif
+
+ return ecx;
+}
+
+//
+// Definitions of the SSE4.2 crc32 operations. Using these instead of
+// the GCC __builtin_* intrinsics allows this code to compile without
+// -msse4.2, since we do dynamic CPU detection at runtime.
+//
+
+# ifdef __LP64__
+inline uint64_t _mm_crc32_u64(uint64_t crc, uint64_t value) {
+ asm("crc32q %[value], %[crc]\n" : [crc] "+r" (crc) : [value] "rm" (value));
+ return crc;
+}
+# endif
+
+inline uint32_t _mm_crc32_u32(uint32_t crc, uint32_t value) {
+ asm("crc32l %[value], %[crc]\n" : [crc] "+r" (crc) : [value] "rm" (value));
+ return crc;
+}
+
+inline uint32_t _mm_crc32_u16(uint32_t crc, uint16_t value) {
+ asm("crc32w %[value], %[crc]\n" : [crc] "+r" (crc) : [value] "rm" (value));
+ return crc;
+}
+
+inline uint32_t _mm_crc32_u8(uint32_t crc, uint8_t value) {
+ asm("crc32b %[value], %[crc]\n" : [crc] "+r" (crc) : [value] "rm" (value));
+ return crc;
+}
+
+# ifdef __LP64__
+/**
+ * Pipelined version of hardware-accelerated CRC32C calculation using
+ * the 64 bit crc32q instruction.
+ * One crc32c instruction takes three cycles, but two more with no data
+ * dependency can be in the pipeline to achieve something close to single
+ * instruction/cycle. Here we feed three blocks in RR.
+ *
+ * crc1, crc2, crc3 : Store initial checksum for each block before
+ * calling. When it returns, updated checksums are stored.
+ * p_buf : The base address of the data buffer. The buffer should be
+ * at least as big as block_size * num_blocks.
+ * block_size : The size of each block in bytes.
+ * num_blocks : The number of blocks to work on. Min = 1, Max = 3
+ */
+static void pipelined_crc32c(uint32_t *crc1, uint32_t *crc2, uint32_t *crc3, const uint8_t *p_buf, size_t block_size, int num_blocks) {
+ uint64_t c1 = *crc1;
+ uint64_t c2 = *crc2;
+ uint64_t c3 = *crc3;
+ uint64_t *data = (uint64_t*)p_buf;
+ int counter = block_size / sizeof(uint64_t);
+ int remainder = block_size % sizeof(uint64_t);
+ uint8_t *bdata;
+
+ /* We do switch here because the loop has to be tight in order
+ * to fill the pipeline. Any other statement inside the loop
+ * or inbetween crc32 instruction can slow things down. Calling
+ * individual crc32 instructions three times from C also causes
+ * gcc to insert other instructions inbetween.
+ *
+ * Do not rearrange the following code unless you have verified
+ * the generated machine code is as efficient as before.
+ */
+ switch (num_blocks) {
+ case 3:
+ /* Do three blocks */
+ while (likely(counter)) {
+ __asm__ __volatile__(
+ "crc32q (%7), %0;\n\t"
+ "crc32q (%7,%6,1), %1;\n\t"
+ "crc32q (%7,%6,2), %2;\n\t"
+ : "=r"(c1), "=r"(c2), "=r"(c3)
+ : "0"(c1), "1"(c2), "2"(c3), "r"(block_size), "r"(data)
+ );
+ data++;
+ counter--;
+ }
+
+ /* Take care of the remainder. They are only up to seven bytes,
+ * so performing byte-level crc32 won't take much time.
+ */
+ bdata = (uint8_t*)data;
+ while (likely(remainder)) {
+ __asm__ __volatile__(
+ "crc32b (%7), %0;\n\t"
+ "crc32b (%7,%6,1), %1;\n\t"
+ "crc32b (%7,%6,2), %2;\n\t"
+ : "=r"(c1), "=r"(c2), "=r"(c3)
+ : "0"(c1), "1"(c2), "2"(c3), "r"(block_size), "r"(bdata)
+ );
+ bdata++;
+ remainder--;
+ }
+ break;
+ case 2:
+ /* Do two blocks */
+ while (likely(counter)) {
+ __asm__ __volatile__(
+ "crc32q (%5), %0;\n\t"
+ "crc32q (%5,%4,1), %1;\n\t"
+ : "=r"(c1), "=r"(c2)
+ : "0"(c1), "1"(c2), "r"(block_size), "r"(data)
+ );
+ data++;
+ counter--;
+ }
+
+ bdata = (uint8_t*)data;
+ while (likely(remainder)) {
+ __asm__ __volatile__(
+ "crc32b (%5), %0;\n\t"
+ "crc32b (%5,%4,1), %1;\n\t"
+ : "=r"(c1), "=r"(c2)
+ : "0"(c1), "1"(c2), "r"(block_size), "r"(bdata)
+ );
+ bdata++;
+ remainder--;
+ }
+ break;
+ case 1:
+ /* single block */
+ while (likely(counter)) {
+ __asm__ __volatile__(
+ "crc32q (%2), %0;\n\t"
+ : "=r"(c1)
+ : "0"(c1), "r"(data)
+ );
+ data++;
+ counter--;
+ }
+ bdata = (uint8_t*)data;
+ while (likely(remainder)) {
+ __asm__ __volatile__(
+ "crc32b (%2), %0;\n\t"
+ : "=r"(c1)
+ : "0"(c1), "r"(bdata)
+ );
+ bdata++;
+ remainder--;
+ }
+ break;
+ case 0:
+ return;
+ default:
+ assert(0 && "BUG: Invalid number of checksum blocks");
+ }
+
+ *crc1 = c1;
+ *crc2 = c2;
+ *crc3 = c3;
+ return;
+}
+
+# else // 32-bit
+
+/**
+ * Pipelined version of hardware-accelerated CRC32C calculation using
+ * the 32 bit crc32l instruction.
+ * One crc32c instruction takes three cycles, but two more with no data
+ * dependency can be in the pipeline to achieve something close to single
+ * instruction/cycle. Here we feed three blocks in RR.
+ *
+ * crc1, crc2, crc3 : Store initial checksum for each block before
+ * calling. When it returns, updated checksums are stored.
+ * data : The base address of the data buffer. The buffer should be
+ * at least as big as block_size * num_blocks.
+ * block_size : The size of each block in bytes.
+ * num_blocks : The number of blocks to work on. Min = 1, Max = 3
+ */
+static void pipelined_crc32c(uint32_t *crc1, uint32_t *crc2, uint32_t *crc3, const uint8_t *p_buf, size_t block_size, int num_blocks) {
+ uint32_t c1 = *crc1;
+ uint32_t c2 = *crc2;
+ uint32_t c3 = *crc3;
+ int counter = block_size / sizeof(uint32_t);
+ int remainder = block_size % sizeof(uint32_t);
+ uint32_t *data = (uint32_t*)p_buf;
+ uint8_t *bdata;
+
+ /* We do switch here because the loop has to be tight in order
+ * to fill the pipeline. Any other statement inside the loop
+ * or inbetween crc32 instruction can slow things down. Calling
+ * individual crc32 instructions three times from C also causes
+ * gcc to insert other instructions inbetween.
+ *
+ * Do not rearrange the following code unless you have verified
+ * the generated machine code is as efficient as before.
+ */
+ switch (num_blocks) {
+ case 3:
+ /* Do three blocks */
+ while (likely(counter)) {
+ __asm__ __volatile__(
+ "crc32l (%7), %0;\n\t"
+ "crc32l (%7,%6,1), %1;\n\t"
+ "crc32l (%7,%6,2), %2;\n\t"
+ : "=r"(c1), "=r"(c2), "=r"(c3)
+ : "r"(c1), "r"(c2), "r"(c3), "r"(block_size), "r"(data)
+ );
+ data++;
+ counter--;
+ }
+ /* Take care of the remainder. They are only up to three bytes,
+ * so performing byte-level crc32 won't take much time.
+ */
+ bdata = (uint8_t*)data;
+ while (likely(remainder)) {
+ __asm__ __volatile__(
+ "crc32b (%7), %0;\n\t"
+ "crc32b (%7,%6,1), %1;\n\t"
+ "crc32b (%7,%6,2), %2;\n\t"
+ : "=r"(c1), "=r"(c2), "=r"(c3)
+ : "r"(c1), "r"(c2), "r"(c3), "r"(block_size), "r"(bdata)
+ );
+ bdata++;
+ remainder--;
+ }
+ break;
+ case 2:
+ /* Do two blocks */
+ while (likely(counter)) {
+ __asm__ __volatile__(
+ "crc32l (%5), %0;\n\t"
+ "crc32l (%5,%4,1), %1;\n\t"
+ : "=r"(c1), "=r"(c2)
+ : "r"(c1), "r"(c2), "r"(block_size), "r"(data)
+ );
+ data++;
+ counter--;
+ }
+
+ bdata = (uint8_t*)data;
+ while (likely(remainder)) {
+ __asm__ __volatile__(
+ "crc32b (%5), %0;\n\t"
+ "crc32b (%5,%4,1), %1;\n\t"
+ : "=r"(c1), "=r"(c2)
+ : "r"(c1), "r"(c2), "r"(block_size), "r"(bdata)
+ );
+ bdata++;
+ remainder--;
+ }
+ break;
+ case 1:
+ /* single block */
+ while (likely(counter)) {
+ __asm__ __volatile__(
+ "crc32l (%2), %0;\n\t"
+ : "=r"(c1)
+ : "r"(c1), "r"(data)
+ );
+ data++;
+ counter--;
+ }
+ bdata = (uint8_t*)data;
+ while (likely(remainder)) {
+ __asm__ __volatile__(
+ "crc32b (%2), %0;\n\t"
+ : "=r"(c1)
+ : "r"(c1), "r"(bdata)
+ );
+ bdata++;
+ remainder--;
+ }
+ break;
+ case 0:
+ return;
+ default:
+ assert(0 && "BUG: Invalid number of checksum blocks");
+ }
+
+ *crc1 = c1;
+ *crc2 = c2;
+ *crc3 = c3;
+ return;
+}
+
+# endif // 64-bit vs 32-bit
+
+/**
+ * On library load, initiailize the cached function pointer
+ * if cpu supports SSE4.2's crc32 instruction.
+ */
+typedef void (*crc_pipelined_func_t)(uint32_t *, uint32_t *, uint32_t *, const uint8_t *, size_t, int);
+extern crc_pipelined_func_t pipelined_crc32c_func;
+
+void __attribute__ ((constructor)) init_cpu_support_flag(void) {
+ uint32_t ecx = cpuid(CPUID_FEATURES);
+ if (ecx & SSE42_FEATURE_BIT) pipelined_crc32c_func = pipelined_crc32c;
+}
diff --git a/ratis-common/src/main/native/src/org/apache/ratis/util/crc32_zlib_polynomial_tables.h b/ratis-common/src/main/native/src/org/apache/ratis/util/crc32_zlib_polynomial_tables.h
new file mode 100644
index 0000000000..59d8f4dfc6
--- /dev/null
+++ b/ratis-common/src/main/native/src/org/apache/ratis/util/crc32_zlib_polynomial_tables.h
@@ -0,0 +1,552 @@
+/*
+ * 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.
+ */
+
+/*
+ * CRC-32 lookup tables generated by the polynomial 0xEDB88320.
+ * See also TestPureJavaCrc32.Table.
+ */
+const uint32_t CRC32_T8_0[] = {
+ 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
+ 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
+ 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
+ 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
+ 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
+ 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
+ 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
+ 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
+ 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
+ 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+ 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
+ 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
+ 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
+ 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
+ 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
+ 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
+ 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
+ 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+ 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
+ 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
+ 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
+ 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
+ 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
+ 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+ 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
+ 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
+ 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
+ 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
+ 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
+ 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+ 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
+ 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
+ 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
+ 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
+ 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
+ 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+ 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
+ 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
+ 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
+ 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
+ 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
+ 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+ 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
+ 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
+ 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+ 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
+ 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
+ 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+ 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
+ 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
+ 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
+ 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
+ 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
+ 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+ 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
+ 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
+ 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
+ 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
+ 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
+ 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+ 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
+ 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
+ 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
+ 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+};
+const uint32_t CRC32_T8_1[] = {
+ 0x00000000, 0x191B3141, 0x32366282, 0x2B2D53C3,
+ 0x646CC504, 0x7D77F445, 0x565AA786, 0x4F4196C7,
+ 0xC8D98A08, 0xD1C2BB49, 0xFAEFE88A, 0xE3F4D9CB,
+ 0xACB54F0C, 0xB5AE7E4D, 0x9E832D8E, 0x87981CCF,
+ 0x4AC21251, 0x53D92310, 0x78F470D3, 0x61EF4192,
+ 0x2EAED755, 0x37B5E614, 0x1C98B5D7, 0x05838496,
+ 0x821B9859, 0x9B00A918, 0xB02DFADB, 0xA936CB9A,
+ 0xE6775D5D, 0xFF6C6C1C, 0xD4413FDF, 0xCD5A0E9E,
+ 0x958424A2, 0x8C9F15E3, 0xA7B24620, 0xBEA97761,
+ 0xF1E8E1A6, 0xE8F3D0E7, 0xC3DE8324, 0xDAC5B265,
+ 0x5D5DAEAA, 0x44469FEB, 0x6F6BCC28, 0x7670FD69,
+ 0x39316BAE, 0x202A5AEF, 0x0B07092C, 0x121C386D,
+ 0xDF4636F3, 0xC65D07B2, 0xED705471, 0xF46B6530,
+ 0xBB2AF3F7, 0xA231C2B6, 0x891C9175, 0x9007A034,
+ 0x179FBCFB, 0x0E848DBA, 0x25A9DE79, 0x3CB2EF38,
+ 0x73F379FF, 0x6AE848BE, 0x41C51B7D, 0x58DE2A3C,
+ 0xF0794F05, 0xE9627E44, 0xC24F2D87, 0xDB541CC6,
+ 0x94158A01, 0x8D0EBB40, 0xA623E883, 0xBF38D9C2,
+ 0x38A0C50D, 0x21BBF44C, 0x0A96A78F, 0x138D96CE,
+ 0x5CCC0009, 0x45D73148, 0x6EFA628B, 0x77E153CA,
+ 0xBABB5D54, 0xA3A06C15, 0x888D3FD6, 0x91960E97,
+ 0xDED79850, 0xC7CCA911, 0xECE1FAD2, 0xF5FACB93,
+ 0x7262D75C, 0x6B79E61D, 0x4054B5DE, 0x594F849F,
+ 0x160E1258, 0x0F152319, 0x243870DA, 0x3D23419B,
+ 0x65FD6BA7, 0x7CE65AE6, 0x57CB0925, 0x4ED03864,
+ 0x0191AEA3, 0x188A9FE2, 0x33A7CC21, 0x2ABCFD60,
+ 0xAD24E1AF, 0xB43FD0EE, 0x9F12832D, 0x8609B26C,
+ 0xC94824AB, 0xD05315EA, 0xFB7E4629, 0xE2657768,
+ 0x2F3F79F6, 0x362448B7, 0x1D091B74, 0x04122A35,
+ 0x4B53BCF2, 0x52488DB3, 0x7965DE70, 0x607EEF31,
+ 0xE7E6F3FE, 0xFEFDC2BF, 0xD5D0917C, 0xCCCBA03D,
+ 0x838A36FA, 0x9A9107BB, 0xB1BC5478, 0xA8A76539,
+ 0x3B83984B, 0x2298A90A, 0x09B5FAC9, 0x10AECB88,
+ 0x5FEF5D4F, 0x46F46C0E, 0x6DD93FCD, 0x74C20E8C,
+ 0xF35A1243, 0xEA412302, 0xC16C70C1, 0xD8774180,
+ 0x9736D747, 0x8E2DE606, 0xA500B5C5, 0xBC1B8484,
+ 0x71418A1A, 0x685ABB5B, 0x4377E898, 0x5A6CD9D9,
+ 0x152D4F1E, 0x0C367E5F, 0x271B2D9C, 0x3E001CDD,
+ 0xB9980012, 0xA0833153, 0x8BAE6290, 0x92B553D1,
+ 0xDDF4C516, 0xC4EFF457, 0xEFC2A794, 0xF6D996D5,
+ 0xAE07BCE9, 0xB71C8DA8, 0x9C31DE6B, 0x852AEF2A,
+ 0xCA6B79ED, 0xD37048AC, 0xF85D1B6F, 0xE1462A2E,
+ 0x66DE36E1, 0x7FC507A0, 0x54E85463, 0x4DF36522,
+ 0x02B2F3E5, 0x1BA9C2A4, 0x30849167, 0x299FA026,
+ 0xE4C5AEB8, 0xFDDE9FF9, 0xD6F3CC3A, 0xCFE8FD7B,
+ 0x80A96BBC, 0x99B25AFD, 0xB29F093E, 0xAB84387F,
+ 0x2C1C24B0, 0x350715F1, 0x1E2A4632, 0x07317773,
+ 0x4870E1B4, 0x516BD0F5, 0x7A468336, 0x635DB277,
+ 0xCBFAD74E, 0xD2E1E60F, 0xF9CCB5CC, 0xE0D7848D,
+ 0xAF96124A, 0xB68D230B, 0x9DA070C8, 0x84BB4189,
+ 0x03235D46, 0x1A386C07, 0x31153FC4, 0x280E0E85,
+ 0x674F9842, 0x7E54A903, 0x5579FAC0, 0x4C62CB81,
+ 0x8138C51F, 0x9823F45E, 0xB30EA79D, 0xAA1596DC,
+ 0xE554001B, 0xFC4F315A, 0xD7626299, 0xCE7953D8,
+ 0x49E14F17, 0x50FA7E56, 0x7BD72D95, 0x62CC1CD4,
+ 0x2D8D8A13, 0x3496BB52, 0x1FBBE891, 0x06A0D9D0,
+ 0x5E7EF3EC, 0x4765C2AD, 0x6C48916E, 0x7553A02F,
+ 0x3A1236E8, 0x230907A9, 0x0824546A, 0x113F652B,
+ 0x96A779E4, 0x8FBC48A5, 0xA4911B66, 0xBD8A2A27,
+ 0xF2CBBCE0, 0xEBD08DA1, 0xC0FDDE62, 0xD9E6EF23,
+ 0x14BCE1BD, 0x0DA7D0FC, 0x268A833F, 0x3F91B27E,
+ 0x70D024B9, 0x69CB15F8, 0x42E6463B, 0x5BFD777A,
+ 0xDC656BB5, 0xC57E5AF4, 0xEE530937, 0xF7483876,
+ 0xB809AEB1, 0xA1129FF0, 0x8A3FCC33, 0x9324FD72
+};
+const uint32_t CRC32_T8_2[] = {
+ 0x00000000, 0x01C26A37, 0x0384D46E, 0x0246BE59,
+ 0x0709A8DC, 0x06CBC2EB, 0x048D7CB2, 0x054F1685,
+ 0x0E1351B8, 0x0FD13B8F, 0x0D9785D6, 0x0C55EFE1,
+ 0x091AF964, 0x08D89353, 0x0A9E2D0A, 0x0B5C473D,
+ 0x1C26A370, 0x1DE4C947, 0x1FA2771E, 0x1E601D29,
+ 0x1B2F0BAC, 0x1AED619B, 0x18ABDFC2, 0x1969B5F5,
+ 0x1235F2C8, 0x13F798FF, 0x11B126A6, 0x10734C91,
+ 0x153C5A14, 0x14FE3023, 0x16B88E7A, 0x177AE44D,
+ 0x384D46E0, 0x398F2CD7, 0x3BC9928E, 0x3A0BF8B9,
+ 0x3F44EE3C, 0x3E86840B, 0x3CC03A52, 0x3D025065,
+ 0x365E1758, 0x379C7D6F, 0x35DAC336, 0x3418A901,
+ 0x3157BF84, 0x3095D5B3, 0x32D36BEA, 0x331101DD,
+ 0x246BE590, 0x25A98FA7, 0x27EF31FE, 0x262D5BC9,
+ 0x23624D4C, 0x22A0277B, 0x20E69922, 0x2124F315,
+ 0x2A78B428, 0x2BBADE1F, 0x29FC6046, 0x283E0A71,
+ 0x2D711CF4, 0x2CB376C3, 0x2EF5C89A, 0x2F37A2AD,
+ 0x709A8DC0, 0x7158E7F7, 0x731E59AE, 0x72DC3399,
+ 0x7793251C, 0x76514F2B, 0x7417F172, 0x75D59B45,
+ 0x7E89DC78, 0x7F4BB64F, 0x7D0D0816, 0x7CCF6221,
+ 0x798074A4, 0x78421E93, 0x7A04A0CA, 0x7BC6CAFD,
+ 0x6CBC2EB0, 0x6D7E4487, 0x6F38FADE, 0x6EFA90E9,
+ 0x6BB5866C, 0x6A77EC5B, 0x68315202, 0x69F33835,
+ 0x62AF7F08, 0x636D153F, 0x612BAB66, 0x60E9C151,
+ 0x65A6D7D4, 0x6464BDE3, 0x662203BA, 0x67E0698D,
+ 0x48D7CB20, 0x4915A117, 0x4B531F4E, 0x4A917579,
+ 0x4FDE63FC, 0x4E1C09CB, 0x4C5AB792, 0x4D98DDA5,
+ 0x46C49A98, 0x4706F0AF, 0x45404EF6, 0x448224C1,
+ 0x41CD3244, 0x400F5873, 0x4249E62A, 0x438B8C1D,
+ 0x54F16850, 0x55330267, 0x5775BC3E, 0x56B7D609,
+ 0x53F8C08C, 0x523AAABB, 0x507C14E2, 0x51BE7ED5,
+ 0x5AE239E8, 0x5B2053DF, 0x5966ED86, 0x58A487B1,
+ 0x5DEB9134, 0x5C29FB03, 0x5E6F455A, 0x5FAD2F6D,
+ 0xE1351B80, 0xE0F771B7, 0xE2B1CFEE, 0xE373A5D9,
+ 0xE63CB35C, 0xE7FED96B, 0xE5B86732, 0xE47A0D05,
+ 0xEF264A38, 0xEEE4200F, 0xECA29E56, 0xED60F461,
+ 0xE82FE2E4, 0xE9ED88D3, 0xEBAB368A, 0xEA695CBD,
+ 0xFD13B8F0, 0xFCD1D2C7, 0xFE976C9E, 0xFF5506A9,
+ 0xFA1A102C, 0xFBD87A1B, 0xF99EC442, 0xF85CAE75,
+ 0xF300E948, 0xF2C2837F, 0xF0843D26, 0xF1465711,
+ 0xF4094194, 0xF5CB2BA3, 0xF78D95FA, 0xF64FFFCD,
+ 0xD9785D60, 0xD8BA3757, 0xDAFC890E, 0xDB3EE339,
+ 0xDE71F5BC, 0xDFB39F8B, 0xDDF521D2, 0xDC374BE5,
+ 0xD76B0CD8, 0xD6A966EF, 0xD4EFD8B6, 0xD52DB281,
+ 0xD062A404, 0xD1A0CE33, 0xD3E6706A, 0xD2241A5D,
+ 0xC55EFE10, 0xC49C9427, 0xC6DA2A7E, 0xC7184049,
+ 0xC25756CC, 0xC3953CFB, 0xC1D382A2, 0xC011E895,
+ 0xCB4DAFA8, 0xCA8FC59F, 0xC8C97BC6, 0xC90B11F1,
+ 0xCC440774, 0xCD866D43, 0xCFC0D31A, 0xCE02B92D,
+ 0x91AF9640, 0x906DFC77, 0x922B422E, 0x93E92819,
+ 0x96A63E9C, 0x976454AB, 0x9522EAF2, 0x94E080C5,
+ 0x9FBCC7F8, 0x9E7EADCF, 0x9C381396, 0x9DFA79A1,
+ 0x98B56F24, 0x99770513, 0x9B31BB4A, 0x9AF3D17D,
+ 0x8D893530, 0x8C4B5F07, 0x8E0DE15E, 0x8FCF8B69,
+ 0x8A809DEC, 0x8B42F7DB, 0x89044982, 0x88C623B5,
+ 0x839A6488, 0x82580EBF, 0x801EB0E6, 0x81DCDAD1,
+ 0x8493CC54, 0x8551A663, 0x8717183A, 0x86D5720D,
+ 0xA9E2D0A0, 0xA820BA97, 0xAA6604CE, 0xABA46EF9,
+ 0xAEEB787C, 0xAF29124B, 0xAD6FAC12, 0xACADC625,
+ 0xA7F18118, 0xA633EB2F, 0xA4755576, 0xA5B73F41,
+ 0xA0F829C4, 0xA13A43F3, 0xA37CFDAA, 0xA2BE979D,
+ 0xB5C473D0, 0xB40619E7, 0xB640A7BE, 0xB782CD89,
+ 0xB2CDDB0C, 0xB30FB13B, 0xB1490F62, 0xB08B6555,
+ 0xBBD72268, 0xBA15485F, 0xB853F606, 0xB9919C31,
+ 0xBCDE8AB4, 0xBD1CE083, 0xBF5A5EDA, 0xBE9834ED
+};
+const uint32_t CRC32_T8_3[] = {
+ 0x00000000, 0xB8BC6765, 0xAA09C88B, 0x12B5AFEE,
+ 0x8F629757, 0x37DEF032, 0x256B5FDC, 0x9DD738B9,
+ 0xC5B428EF, 0x7D084F8A, 0x6FBDE064, 0xD7018701,
+ 0x4AD6BFB8, 0xF26AD8DD, 0xE0DF7733, 0x58631056,
+ 0x5019579F, 0xE8A530FA, 0xFA109F14, 0x42ACF871,
+ 0xDF7BC0C8, 0x67C7A7AD, 0x75720843, 0xCDCE6F26,
+ 0x95AD7F70, 0x2D111815, 0x3FA4B7FB, 0x8718D09E,
+ 0x1ACFE827, 0xA2738F42, 0xB0C620AC, 0x087A47C9,
+ 0xA032AF3E, 0x188EC85B, 0x0A3B67B5, 0xB28700D0,
+ 0x2F503869, 0x97EC5F0C, 0x8559F0E2, 0x3DE59787,
+ 0x658687D1, 0xDD3AE0B4, 0xCF8F4F5A, 0x7733283F,
+ 0xEAE41086, 0x525877E3, 0x40EDD80D, 0xF851BF68,
+ 0xF02BF8A1, 0x48979FC4, 0x5A22302A, 0xE29E574F,
+ 0x7F496FF6, 0xC7F50893, 0xD540A77D, 0x6DFCC018,
+ 0x359FD04E, 0x8D23B72B, 0x9F9618C5, 0x272A7FA0,
+ 0xBAFD4719, 0x0241207C, 0x10F48F92, 0xA848E8F7,
+ 0x9B14583D, 0x23A83F58, 0x311D90B6, 0x89A1F7D3,
+ 0x1476CF6A, 0xACCAA80F, 0xBE7F07E1, 0x06C36084,
+ 0x5EA070D2, 0xE61C17B7, 0xF4A9B859, 0x4C15DF3C,
+ 0xD1C2E785, 0x697E80E0, 0x7BCB2F0E, 0xC377486B,
+ 0xCB0D0FA2, 0x73B168C7, 0x6104C729, 0xD9B8A04C,
+ 0x446F98F5, 0xFCD3FF90, 0xEE66507E, 0x56DA371B,
+ 0x0EB9274D, 0xB6054028, 0xA4B0EFC6, 0x1C0C88A3,
+ 0x81DBB01A, 0x3967D77F, 0x2BD27891, 0x936E1FF4,
+ 0x3B26F703, 0x839A9066, 0x912F3F88, 0x299358ED,
+ 0xB4446054, 0x0CF80731, 0x1E4DA8DF, 0xA6F1CFBA,
+ 0xFE92DFEC, 0x462EB889, 0x549B1767, 0xEC277002,
+ 0x71F048BB, 0xC94C2FDE, 0xDBF98030, 0x6345E755,
+ 0x6B3FA09C, 0xD383C7F9, 0xC1366817, 0x798A0F72,
+ 0xE45D37CB, 0x5CE150AE, 0x4E54FF40, 0xF6E89825,
+ 0xAE8B8873, 0x1637EF16, 0x048240F8, 0xBC3E279D,
+ 0x21E91F24, 0x99557841, 0x8BE0D7AF, 0x335CB0CA,
+ 0xED59B63B, 0x55E5D15E, 0x47507EB0, 0xFFEC19D5,
+ 0x623B216C, 0xDA874609, 0xC832E9E7, 0x708E8E82,
+ 0x28ED9ED4, 0x9051F9B1, 0x82E4565F, 0x3A58313A,
+ 0xA78F0983, 0x1F336EE6, 0x0D86C108, 0xB53AA66D,
+ 0xBD40E1A4, 0x05FC86C1, 0x1749292F, 0xAFF54E4A,
+ 0x322276F3, 0x8A9E1196, 0x982BBE78, 0x2097D91D,
+ 0x78F4C94B, 0xC048AE2E, 0xD2FD01C0, 0x6A4166A5,
+ 0xF7965E1C, 0x4F2A3979, 0x5D9F9697, 0xE523F1F2,
+ 0x4D6B1905, 0xF5D77E60, 0xE762D18E, 0x5FDEB6EB,
+ 0xC2098E52, 0x7AB5E937, 0x680046D9, 0xD0BC21BC,
+ 0x88DF31EA, 0x3063568F, 0x22D6F961, 0x9A6A9E04,
+ 0x07BDA6BD, 0xBF01C1D8, 0xADB46E36, 0x15080953,
+ 0x1D724E9A, 0xA5CE29FF, 0xB77B8611, 0x0FC7E174,
+ 0x9210D9CD, 0x2AACBEA8, 0x38191146, 0x80A57623,
+ 0xD8C66675, 0x607A0110, 0x72CFAEFE, 0xCA73C99B,
+ 0x57A4F122, 0xEF189647, 0xFDAD39A9, 0x45115ECC,
+ 0x764DEE06, 0xCEF18963, 0xDC44268D, 0x64F841E8,
+ 0xF92F7951, 0x41931E34, 0x5326B1DA, 0xEB9AD6BF,
+ 0xB3F9C6E9, 0x0B45A18C, 0x19F00E62, 0xA14C6907,
+ 0x3C9B51BE, 0x842736DB, 0x96929935, 0x2E2EFE50,
+ 0x2654B999, 0x9EE8DEFC, 0x8C5D7112, 0x34E11677,
+ 0xA9362ECE, 0x118A49AB, 0x033FE645, 0xBB838120,
+ 0xE3E09176, 0x5B5CF613, 0x49E959FD, 0xF1553E98,
+ 0x6C820621, 0xD43E6144, 0xC68BCEAA, 0x7E37A9CF,
+ 0xD67F4138, 0x6EC3265D, 0x7C7689B3, 0xC4CAEED6,
+ 0x591DD66F, 0xE1A1B10A, 0xF3141EE4, 0x4BA87981,
+ 0x13CB69D7, 0xAB770EB2, 0xB9C2A15C, 0x017EC639,
+ 0x9CA9FE80, 0x241599E5, 0x36A0360B, 0x8E1C516E,
+ 0x866616A7, 0x3EDA71C2, 0x2C6FDE2C, 0x94D3B949,
+ 0x090481F0, 0xB1B8E695, 0xA30D497B, 0x1BB12E1E,
+ 0x43D23E48, 0xFB6E592D, 0xE9DBF6C3, 0x516791A6,
+ 0xCCB0A91F, 0x740CCE7A, 0x66B96194, 0xDE0506F1
+};
+const uint32_t CRC32_T8_4[] = {
+ 0x00000000, 0x3D6029B0, 0x7AC05360, 0x47A07AD0,
+ 0xF580A6C0, 0xC8E08F70, 0x8F40F5A0, 0xB220DC10,
+ 0x30704BC1, 0x0D106271, 0x4AB018A1, 0x77D03111,
+ 0xC5F0ED01, 0xF890C4B1, 0xBF30BE61, 0x825097D1,
+ 0x60E09782, 0x5D80BE32, 0x1A20C4E2, 0x2740ED52,
+ 0x95603142, 0xA80018F2, 0xEFA06222, 0xD2C04B92,
+ 0x5090DC43, 0x6DF0F5F3, 0x2A508F23, 0x1730A693,
+ 0xA5107A83, 0x98705333, 0xDFD029E3, 0xE2B00053,
+ 0xC1C12F04, 0xFCA106B4, 0xBB017C64, 0x866155D4,
+ 0x344189C4, 0x0921A074, 0x4E81DAA4, 0x73E1F314,
+ 0xF1B164C5, 0xCCD14D75, 0x8B7137A5, 0xB6111E15,
+ 0x0431C205, 0x3951EBB5, 0x7EF19165, 0x4391B8D5,
+ 0xA121B886, 0x9C419136, 0xDBE1EBE6, 0xE681C256,
+ 0x54A11E46, 0x69C137F6, 0x2E614D26, 0x13016496,
+ 0x9151F347, 0xAC31DAF7, 0xEB91A027, 0xD6F18997,
+ 0x64D15587, 0x59B17C37, 0x1E1106E7, 0x23712F57,
+ 0x58F35849, 0x659371F9, 0x22330B29, 0x1F532299,
+ 0xAD73FE89, 0x9013D739, 0xD7B3ADE9, 0xEAD38459,
+ 0x68831388, 0x55E33A38, 0x124340E8, 0x2F236958,
+ 0x9D03B548, 0xA0639CF8, 0xE7C3E628, 0xDAA3CF98,
+ 0x3813CFCB, 0x0573E67B, 0x42D39CAB, 0x7FB3B51B,
+ 0xCD93690B, 0xF0F340BB, 0xB7533A6B, 0x8A3313DB,
+ 0x0863840A, 0x3503ADBA, 0x72A3D76A, 0x4FC3FEDA,
+ 0xFDE322CA, 0xC0830B7A, 0x872371AA, 0xBA43581A,
+ 0x9932774D, 0xA4525EFD, 0xE3F2242D, 0xDE920D9D,
+ 0x6CB2D18D, 0x51D2F83D, 0x167282ED, 0x2B12AB5D,
+ 0xA9423C8C, 0x9422153C, 0xD3826FEC, 0xEEE2465C,
+ 0x5CC29A4C, 0x61A2B3FC, 0x2602C92C, 0x1B62E09C,
+ 0xF9D2E0CF, 0xC4B2C97F, 0x8312B3AF, 0xBE729A1F,
+ 0x0C52460F, 0x31326FBF, 0x7692156F, 0x4BF23CDF,
+ 0xC9A2AB0E, 0xF4C282BE, 0xB362F86E, 0x8E02D1DE,
+ 0x3C220DCE, 0x0142247E, 0x46E25EAE, 0x7B82771E,
+ 0xB1E6B092, 0x8C869922, 0xCB26E3F2, 0xF646CA42,
+ 0x44661652, 0x79063FE2, 0x3EA64532, 0x03C66C82,
+ 0x8196FB53, 0xBCF6D2E3, 0xFB56A833, 0xC6368183,
+ 0x74165D93, 0x49767423, 0x0ED60EF3, 0x33B62743,
+ 0xD1062710, 0xEC660EA0, 0xABC67470, 0x96A65DC0,
+ 0x248681D0, 0x19E6A860, 0x5E46D2B0, 0x6326FB00,
+ 0xE1766CD1, 0xDC164561, 0x9BB63FB1, 0xA6D61601,
+ 0x14F6CA11, 0x2996E3A1, 0x6E369971, 0x5356B0C1,
+ 0x70279F96, 0x4D47B626, 0x0AE7CCF6, 0x3787E546,
+ 0x85A73956, 0xB8C710E6, 0xFF676A36, 0xC2074386,
+ 0x4057D457, 0x7D37FDE7, 0x3A978737, 0x07F7AE87,
+ 0xB5D77297, 0x88B75B27, 0xCF1721F7, 0xF2770847,
+ 0x10C70814, 0x2DA721A4, 0x6A075B74, 0x576772C4,
+ 0xE547AED4, 0xD8278764, 0x9F87FDB4, 0xA2E7D404,
+ 0x20B743D5, 0x1DD76A65, 0x5A7710B5, 0x67173905,
+ 0xD537E515, 0xE857CCA5, 0xAFF7B675, 0x92979FC5,
+ 0xE915E8DB, 0xD475C16B, 0x93D5BBBB, 0xAEB5920B,
+ 0x1C954E1B, 0x21F567AB, 0x66551D7B, 0x5B3534CB,
+ 0xD965A31A, 0xE4058AAA, 0xA3A5F07A, 0x9EC5D9CA,
+ 0x2CE505DA, 0x11852C6A, 0x562556BA, 0x6B457F0A,
+ 0x89F57F59, 0xB49556E9, 0xF3352C39, 0xCE550589,
+ 0x7C75D999, 0x4115F029, 0x06B58AF9, 0x3BD5A349,
+ 0xB9853498, 0x84E51D28, 0xC34567F8, 0xFE254E48,
+ 0x4C059258, 0x7165BBE8, 0x36C5C138, 0x0BA5E888,
+ 0x28D4C7DF, 0x15B4EE6F, 0x521494BF, 0x6F74BD0F,
+ 0xDD54611F, 0xE03448AF, 0xA794327F, 0x9AF41BCF,
+ 0x18A48C1E, 0x25C4A5AE, 0x6264DF7E, 0x5F04F6CE,
+ 0xED242ADE, 0xD044036E, 0x97E479BE, 0xAA84500E,
+ 0x4834505D, 0x755479ED, 0x32F4033D, 0x0F942A8D,
+ 0xBDB4F69D, 0x80D4DF2D, 0xC774A5FD, 0xFA148C4D,
+ 0x78441B9C, 0x4524322C, 0x028448FC, 0x3FE4614C,
+ 0x8DC4BD5C, 0xB0A494EC, 0xF704EE3C, 0xCA64C78C
+};
+const uint32_t CRC32_T8_5[] = {
+ 0x00000000, 0xCB5CD3A5, 0x4DC8A10B, 0x869472AE,
+ 0x9B914216, 0x50CD91B3, 0xD659E31D, 0x1D0530B8,
+ 0xEC53826D, 0x270F51C8, 0xA19B2366, 0x6AC7F0C3,
+ 0x77C2C07B, 0xBC9E13DE, 0x3A0A6170, 0xF156B2D5,
+ 0x03D6029B, 0xC88AD13E, 0x4E1EA390, 0x85427035,
+ 0x9847408D, 0x531B9328, 0xD58FE186, 0x1ED33223,
+ 0xEF8580F6, 0x24D95353, 0xA24D21FD, 0x6911F258,
+ 0x7414C2E0, 0xBF481145, 0x39DC63EB, 0xF280B04E,
+ 0x07AC0536, 0xCCF0D693, 0x4A64A43D, 0x81387798,
+ 0x9C3D4720, 0x57619485, 0xD1F5E62B, 0x1AA9358E,
+ 0xEBFF875B, 0x20A354FE, 0xA6372650, 0x6D6BF5F5,
+ 0x706EC54D, 0xBB3216E8, 0x3DA66446, 0xF6FAB7E3,
+ 0x047A07AD, 0xCF26D408, 0x49B2A6A6, 0x82EE7503,
+ 0x9FEB45BB, 0x54B7961E, 0xD223E4B0, 0x197F3715,
+ 0xE82985C0, 0x23755665, 0xA5E124CB, 0x6EBDF76E,
+ 0x73B8C7D6, 0xB8E41473, 0x3E7066DD, 0xF52CB578,
+ 0x0F580A6C, 0xC404D9C9, 0x4290AB67, 0x89CC78C2,
+ 0x94C9487A, 0x5F959BDF, 0xD901E971, 0x125D3AD4,
+ 0xE30B8801, 0x28575BA4, 0xAEC3290A, 0x659FFAAF,
+ 0x789ACA17, 0xB3C619B2, 0x35526B1C, 0xFE0EB8B9,
+ 0x0C8E08F7, 0xC7D2DB52, 0x4146A9FC, 0x8A1A7A59,
+ 0x971F4AE1, 0x5C439944, 0xDAD7EBEA, 0x118B384F,
+ 0xE0DD8A9A, 0x2B81593F, 0xAD152B91, 0x6649F834,
+ 0x7B4CC88C, 0xB0101B29, 0x36846987, 0xFDD8BA22,
+ 0x08F40F5A, 0xC3A8DCFF, 0x453CAE51, 0x8E607DF4,
+ 0x93654D4C, 0x58399EE9, 0xDEADEC47, 0x15F13FE2,
+ 0xE4A78D37, 0x2FFB5E92, 0xA96F2C3C, 0x6233FF99,
+ 0x7F36CF21, 0xB46A1C84, 0x32FE6E2A, 0xF9A2BD8F,
+ 0x0B220DC1, 0xC07EDE64, 0x46EAACCA, 0x8DB67F6F,
+ 0x90B34FD7, 0x5BEF9C72, 0xDD7BEEDC, 0x16273D79,
+ 0xE7718FAC, 0x2C2D5C09, 0xAAB92EA7, 0x61E5FD02,
+ 0x7CE0CDBA, 0xB7BC1E1F, 0x31286CB1, 0xFA74BF14,
+ 0x1EB014D8, 0xD5ECC77D, 0x5378B5D3, 0x98246676,
+ 0x852156CE, 0x4E7D856B, 0xC8E9F7C5, 0x03B52460,
+ 0xF2E396B5, 0x39BF4510, 0xBF2B37BE, 0x7477E41B,
+ 0x6972D4A3, 0xA22E0706, 0x24BA75A8, 0xEFE6A60D,
+ 0x1D661643, 0xD63AC5E6, 0x50AEB748, 0x9BF264ED,
+ 0x86F75455, 0x4DAB87F0, 0xCB3FF55E, 0x006326FB,
+ 0xF135942E, 0x3A69478B, 0xBCFD3525, 0x77A1E680,
+ 0x6AA4D638, 0xA1F8059D, 0x276C7733, 0xEC30A496,
+ 0x191C11EE, 0xD240C24B, 0x54D4B0E5, 0x9F886340,
+ 0x828D53F8, 0x49D1805D, 0xCF45F2F3, 0x04192156,
+ 0xF54F9383, 0x3E134026, 0xB8873288, 0x73DBE12D,
+ 0x6EDED195, 0xA5820230, 0x2316709E, 0xE84AA33B,
+ 0x1ACA1375, 0xD196C0D0, 0x5702B27E, 0x9C5E61DB,
+ 0x815B5163, 0x4A0782C6, 0xCC93F068, 0x07CF23CD,
+ 0xF6999118, 0x3DC542BD, 0xBB513013, 0x700DE3B6,
+ 0x6D08D30E, 0xA65400AB, 0x20C07205, 0xEB9CA1A0,
+ 0x11E81EB4, 0xDAB4CD11, 0x5C20BFBF, 0x977C6C1A,
+ 0x8A795CA2, 0x41258F07, 0xC7B1FDA9, 0x0CED2E0C,
+ 0xFDBB9CD9, 0x36E74F7C, 0xB0733DD2, 0x7B2FEE77,
+ 0x662ADECF, 0xAD760D6A, 0x2BE27FC4, 0xE0BEAC61,
+ 0x123E1C2F, 0xD962CF8A, 0x5FF6BD24, 0x94AA6E81,
+ 0x89AF5E39, 0x42F38D9C, 0xC467FF32, 0x0F3B2C97,
+ 0xFE6D9E42, 0x35314DE7, 0xB3A53F49, 0x78F9ECEC,
+ 0x65FCDC54, 0xAEA00FF1, 0x28347D5F, 0xE368AEFA,
+ 0x16441B82, 0xDD18C827, 0x5B8CBA89, 0x90D0692C,
+ 0x8DD55994, 0x46898A31, 0xC01DF89F, 0x0B412B3A,
+ 0xFA1799EF, 0x314B4A4A, 0xB7DF38E4, 0x7C83EB41,
+ 0x6186DBF9, 0xAADA085C, 0x2C4E7AF2, 0xE712A957,
+ 0x15921919, 0xDECECABC, 0x585AB812, 0x93066BB7,
+ 0x8E035B0F, 0x455F88AA, 0xC3CBFA04, 0x089729A1,
+ 0xF9C19B74, 0x329D48D1, 0xB4093A7F, 0x7F55E9DA,
+ 0x6250D962, 0xA90C0AC7, 0x2F987869, 0xE4C4ABCC
+};
+const uint32_t CRC32_T8_6[] = {
+ 0x00000000, 0xA6770BB4, 0x979F1129, 0x31E81A9D,
+ 0xF44F2413, 0x52382FA7, 0x63D0353A, 0xC5A73E8E,
+ 0x33EF4E67, 0x959845D3, 0xA4705F4E, 0x020754FA,
+ 0xC7A06A74, 0x61D761C0, 0x503F7B5D, 0xF64870E9,
+ 0x67DE9CCE, 0xC1A9977A, 0xF0418DE7, 0x56368653,
+ 0x9391B8DD, 0x35E6B369, 0x040EA9F4, 0xA279A240,
+ 0x5431D2A9, 0xF246D91D, 0xC3AEC380, 0x65D9C834,
+ 0xA07EF6BA, 0x0609FD0E, 0x37E1E793, 0x9196EC27,
+ 0xCFBD399C, 0x69CA3228, 0x582228B5, 0xFE552301,
+ 0x3BF21D8F, 0x9D85163B, 0xAC6D0CA6, 0x0A1A0712,
+ 0xFC5277FB, 0x5A257C4F, 0x6BCD66D2, 0xCDBA6D66,
+ 0x081D53E8, 0xAE6A585C, 0x9F8242C1, 0x39F54975,
+ 0xA863A552, 0x0E14AEE6, 0x3FFCB47B, 0x998BBFCF,
+ 0x5C2C8141, 0xFA5B8AF5, 0xCBB39068, 0x6DC49BDC,
+ 0x9B8CEB35, 0x3DFBE081, 0x0C13FA1C, 0xAA64F1A8,
+ 0x6FC3CF26, 0xC9B4C492, 0xF85CDE0F, 0x5E2BD5BB,
+ 0x440B7579, 0xE27C7ECD, 0xD3946450, 0x75E36FE4,
+ 0xB044516A, 0x16335ADE, 0x27DB4043, 0x81AC4BF7,
+ 0x77E43B1E, 0xD19330AA, 0xE07B2A37, 0x460C2183,
+ 0x83AB1F0D, 0x25DC14B9, 0x14340E24, 0xB2430590,
+ 0x23D5E9B7, 0x85A2E203, 0xB44AF89E, 0x123DF32A,
+ 0xD79ACDA4, 0x71EDC610, 0x4005DC8D, 0xE672D739,
+ 0x103AA7D0, 0xB64DAC64, 0x87A5B6F9, 0x21D2BD4D,
+ 0xE47583C3, 0x42028877, 0x73EA92EA, 0xD59D995E,
+ 0x8BB64CE5, 0x2DC14751, 0x1C295DCC, 0xBA5E5678,
+ 0x7FF968F6, 0xD98E6342, 0xE86679DF, 0x4E11726B,
+ 0xB8590282, 0x1E2E0936, 0x2FC613AB, 0x89B1181F,
+ 0x4C162691, 0xEA612D25, 0xDB8937B8, 0x7DFE3C0C,
+ 0xEC68D02B, 0x4A1FDB9F, 0x7BF7C102, 0xDD80CAB6,
+ 0x1827F438, 0xBE50FF8C, 0x8FB8E511, 0x29CFEEA5,
+ 0xDF879E4C, 0x79F095F8, 0x48188F65, 0xEE6F84D1,
+ 0x2BC8BA5F, 0x8DBFB1EB, 0xBC57AB76, 0x1A20A0C2,
+ 0x8816EAF2, 0x2E61E146, 0x1F89FBDB, 0xB9FEF06F,
+ 0x7C59CEE1, 0xDA2EC555, 0xEBC6DFC8, 0x4DB1D47C,
+ 0xBBF9A495, 0x1D8EAF21, 0x2C66B5BC, 0x8A11BE08,
+ 0x4FB68086, 0xE9C18B32, 0xD82991AF, 0x7E5E9A1B,
+ 0xEFC8763C, 0x49BF7D88, 0x78576715, 0xDE206CA1,
+ 0x1B87522F, 0xBDF0599B, 0x8C184306, 0x2A6F48B2,
+ 0xDC27385B, 0x7A5033EF, 0x4BB82972, 0xEDCF22C6,
+ 0x28681C48, 0x8E1F17FC, 0xBFF70D61, 0x198006D5,
+ 0x47ABD36E, 0xE1DCD8DA, 0xD034C247, 0x7643C9F3,
+ 0xB3E4F77D, 0x1593FCC9, 0x247BE654, 0x820CEDE0,
+ 0x74449D09, 0xD23396BD, 0xE3DB8C20, 0x45AC8794,
+ 0x800BB91A, 0x267CB2AE, 0x1794A833, 0xB1E3A387,
+ 0x20754FA0, 0x86024414, 0xB7EA5E89, 0x119D553D,
+ 0xD43A6BB3, 0x724D6007, 0x43A57A9A, 0xE5D2712E,
+ 0x139A01C7, 0xB5ED0A73, 0x840510EE, 0x22721B5A,
+ 0xE7D525D4, 0x41A22E60, 0x704A34FD, 0xD63D3F49,
+ 0xCC1D9F8B, 0x6A6A943F, 0x5B828EA2, 0xFDF58516,
+ 0x3852BB98, 0x9E25B02C, 0xAFCDAAB1, 0x09BAA105,
+ 0xFFF2D1EC, 0x5985DA58, 0x686DC0C5, 0xCE1ACB71,
+ 0x0BBDF5FF, 0xADCAFE4B, 0x9C22E4D6, 0x3A55EF62,
+ 0xABC30345, 0x0DB408F1, 0x3C5C126C, 0x9A2B19D8,
+ 0x5F8C2756, 0xF9FB2CE2, 0xC813367F, 0x6E643DCB,
+ 0x982C4D22, 0x3E5B4696, 0x0FB35C0B, 0xA9C457BF,
+ 0x6C636931, 0xCA146285, 0xFBFC7818, 0x5D8B73AC,
+ 0x03A0A617, 0xA5D7ADA3, 0x943FB73E, 0x3248BC8A,
+ 0xF7EF8204, 0x519889B0, 0x6070932D, 0xC6079899,
+ 0x304FE870, 0x9638E3C4, 0xA7D0F959, 0x01A7F2ED,
+ 0xC400CC63, 0x6277C7D7, 0x539FDD4A, 0xF5E8D6FE,
+ 0x647E3AD9, 0xC209316D, 0xF3E12BF0, 0x55962044,
+ 0x90311ECA, 0x3646157E, 0x07AE0FE3, 0xA1D90457,
+ 0x579174BE, 0xF1E67F0A, 0xC00E6597, 0x66796E23,
+ 0xA3DE50AD, 0x05A95B19, 0x34414184, 0x92364A30
+};
+const uint32_t CRC32_T8_7[] = {
+ 0x00000000, 0xCCAA009E, 0x4225077D, 0x8E8F07E3,
+ 0x844A0EFA, 0x48E00E64, 0xC66F0987, 0x0AC50919,
+ 0xD3E51BB5, 0x1F4F1B2B, 0x91C01CC8, 0x5D6A1C56,
+ 0x57AF154F, 0x9B0515D1, 0x158A1232, 0xD92012AC,
+ 0x7CBB312B, 0xB01131B5, 0x3E9E3656, 0xF23436C8,
+ 0xF8F13FD1, 0x345B3F4F, 0xBAD438AC, 0x767E3832,
+ 0xAF5E2A9E, 0x63F42A00, 0xED7B2DE3, 0x21D12D7D,
+ 0x2B142464, 0xE7BE24FA, 0x69312319, 0xA59B2387,
+ 0xF9766256, 0x35DC62C8, 0xBB53652B, 0x77F965B5,
+ 0x7D3C6CAC, 0xB1966C32, 0x3F196BD1, 0xF3B36B4F,
+ 0x2A9379E3, 0xE639797D, 0x68B67E9E, 0xA41C7E00,
+ 0xAED97719, 0x62737787, 0xECFC7064, 0x205670FA,
+ 0x85CD537D, 0x496753E3, 0xC7E85400, 0x0B42549E,
+ 0x01875D87, 0xCD2D5D19, 0x43A25AFA, 0x8F085A64,
+ 0x562848C8, 0x9A824856, 0x140D4FB5, 0xD8A74F2B,
+ 0xD2624632, 0x1EC846AC, 0x9047414F, 0x5CED41D1,
+ 0x299DC2ED, 0xE537C273, 0x6BB8C590, 0xA712C50E,
+ 0xADD7CC17, 0x617DCC89, 0xEFF2CB6A, 0x2358CBF4,
+ 0xFA78D958, 0x36D2D9C6, 0xB85DDE25, 0x74F7DEBB,
+ 0x7E32D7A2, 0xB298D73C, 0x3C17D0DF, 0xF0BDD041,
+ 0x5526F3C6, 0x998CF358, 0x1703F4BB, 0xDBA9F425,
+ 0xD16CFD3C, 0x1DC6FDA2, 0x9349FA41, 0x5FE3FADF,
+ 0x86C3E873, 0x4A69E8ED, 0xC4E6EF0E, 0x084CEF90,
+ 0x0289E689, 0xCE23E617, 0x40ACE1F4, 0x8C06E16A,
+ 0xD0EBA0BB, 0x1C41A025, 0x92CEA7C6, 0x5E64A758,
+ 0x54A1AE41, 0x980BAEDF, 0x1684A93C, 0xDA2EA9A2,
+ 0x030EBB0E, 0xCFA4BB90, 0x412BBC73, 0x8D81BCED,
+ 0x8744B5F4, 0x4BEEB56A, 0xC561B289, 0x09CBB217,
+ 0xAC509190, 0x60FA910E, 0xEE7596ED, 0x22DF9673,
+ 0x281A9F6A, 0xE4B09FF4, 0x6A3F9817, 0xA6959889,
+ 0x7FB58A25, 0xB31F8ABB, 0x3D908D58, 0xF13A8DC6,
+ 0xFBFF84DF, 0x37558441, 0xB9DA83A2, 0x7570833C,
+ 0x533B85DA, 0x9F918544, 0x111E82A7, 0xDDB48239,
+ 0xD7718B20, 0x1BDB8BBE, 0x95548C5D, 0x59FE8CC3,
+ 0x80DE9E6F, 0x4C749EF1, 0xC2FB9912, 0x0E51998C,
+ 0x04949095, 0xC83E900B, 0x46B197E8, 0x8A1B9776,
+ 0x2F80B4F1, 0xE32AB46F, 0x6DA5B38C, 0xA10FB312,
+ 0xABCABA0B, 0x6760BA95, 0xE9EFBD76, 0x2545BDE8,
+ 0xFC65AF44, 0x30CFAFDA, 0xBE40A839, 0x72EAA8A7,
+ 0x782FA1BE, 0xB485A120, 0x3A0AA6C3, 0xF6A0A65D,
+ 0xAA4DE78C, 0x66E7E712, 0xE868E0F1, 0x24C2E06F,
+ 0x2E07E976, 0xE2ADE9E8, 0x6C22EE0B, 0xA088EE95,
+ 0x79A8FC39, 0xB502FCA7, 0x3B8DFB44, 0xF727FBDA,
+ 0xFDE2F2C3, 0x3148F25D, 0xBFC7F5BE, 0x736DF520,
+ 0xD6F6D6A7, 0x1A5CD639, 0x94D3D1DA, 0x5879D144,
+ 0x52BCD85D, 0x9E16D8C3, 0x1099DF20, 0xDC33DFBE,
+ 0x0513CD12, 0xC9B9CD8C, 0x4736CA6F, 0x8B9CCAF1,
+ 0x8159C3E8, 0x4DF3C376, 0xC37CC495, 0x0FD6C40B,
+ 0x7AA64737, 0xB60C47A9, 0x3883404A, 0xF42940D4,
+ 0xFEEC49CD, 0x32464953, 0xBCC94EB0, 0x70634E2E,
+ 0xA9435C82, 0x65E95C1C, 0xEB665BFF, 0x27CC5B61,
+ 0x2D095278, 0xE1A352E6, 0x6F2C5505, 0xA386559B,
+ 0x061D761C, 0xCAB77682, 0x44387161, 0x889271FF,
+ 0x825778E6, 0x4EFD7878, 0xC0727F9B, 0x0CD87F05,
+ 0xD5F86DA9, 0x19526D37, 0x97DD6AD4, 0x5B776A4A,
+ 0x51B26353, 0x9D1863CD, 0x1397642E, 0xDF3D64B0,
+ 0x83D02561, 0x4F7A25FF, 0xC1F5221C, 0x0D5F2282,
+ 0x079A2B9B, 0xCB302B05, 0x45BF2CE6, 0x89152C78,
+ 0x50353ED4, 0x9C9F3E4A, 0x121039A9, 0xDEBA3937,
+ 0xD47F302E, 0x18D530B0, 0x965A3753, 0x5AF037CD,
+ 0xFF6B144A, 0x33C114D4, 0xBD4E1337, 0x71E413A9,
+ 0x7B211AB0, 0xB78B1A2E, 0x39041DCD, 0xF5AE1D53,
+ 0x2C8E0FFF, 0xE0240F61, 0x6EAB0882, 0xA201081C,
+ 0xA8C40105, 0x646E019B, 0xEAE10678, 0x264B06E6
+};
+
+
diff --git a/ratis-common/src/main/native/src/org/apache/ratis/util/crc32c_tables.h b/ratis-common/src/main/native/src/org/apache/ratis/util/crc32c_tables.h
new file mode 100644
index 0000000000..d54c4dbefc
--- /dev/null
+++ b/ratis-common/src/main/native/src/org/apache/ratis/util/crc32c_tables.h
@@ -0,0 +1,550 @@
+/*
+ * 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.
+ */
+
+/*
+ * CRC-32 lookup tables generated by the polynomial 82F63B78
+ * See also TestPureJavaCrc32.Table.
+ */
+const uint32_t CRC32C_T8_0[256] = {
+ 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4,
+ 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
+ 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B,
+ 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
+ 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B,
+ 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
+ 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54,
+ 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
+ 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A,
+ 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
+ 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5,
+ 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
+ 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45,
+ 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
+ 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A,
+ 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
+ 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48,
+ 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
+ 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687,
+ 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
+ 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927,
+ 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
+ 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8,
+ 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
+ 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096,
+ 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
+ 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859,
+ 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
+ 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9,
+ 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
+ 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36,
+ 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
+ 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C,
+ 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
+ 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043,
+ 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
+ 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3,
+ 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
+ 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C,
+ 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
+ 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652,
+ 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
+ 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D,
+ 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
+ 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D,
+ 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
+ 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2,
+ 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
+ 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530,
+ 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
+ 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF,
+ 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
+ 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F,
+ 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
+ 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90,
+ 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
+ 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE,
+ 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
+ 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321,
+ 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
+ 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81,
+ 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
+ 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E,
+ 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351
+};
+const uint32_t CRC32C_T8_1[256] = {
+ 0x00000000, 0x13A29877, 0x274530EE, 0x34E7A899,
+ 0x4E8A61DC, 0x5D28F9AB, 0x69CF5132, 0x7A6DC945,
+ 0x9D14C3B8, 0x8EB65BCF, 0xBA51F356, 0xA9F36B21,
+ 0xD39EA264, 0xC03C3A13, 0xF4DB928A, 0xE7790AFD,
+ 0x3FC5F181, 0x2C6769F6, 0x1880C16F, 0x0B225918,
+ 0x714F905D, 0x62ED082A, 0x560AA0B3, 0x45A838C4,
+ 0xA2D13239, 0xB173AA4E, 0x859402D7, 0x96369AA0,
+ 0xEC5B53E5, 0xFFF9CB92, 0xCB1E630B, 0xD8BCFB7C,
+ 0x7F8BE302, 0x6C297B75, 0x58CED3EC, 0x4B6C4B9B,
+ 0x310182DE, 0x22A31AA9, 0x1644B230, 0x05E62A47,
+ 0xE29F20BA, 0xF13DB8CD, 0xC5DA1054, 0xD6788823,
+ 0xAC154166, 0xBFB7D911, 0x8B507188, 0x98F2E9FF,
+ 0x404E1283, 0x53EC8AF4, 0x670B226D, 0x74A9BA1A,
+ 0x0EC4735F, 0x1D66EB28, 0x298143B1, 0x3A23DBC6,
+ 0xDD5AD13B, 0xCEF8494C, 0xFA1FE1D5, 0xE9BD79A2,
+ 0x93D0B0E7, 0x80722890, 0xB4958009, 0xA737187E,
+ 0xFF17C604, 0xECB55E73, 0xD852F6EA, 0xCBF06E9D,
+ 0xB19DA7D8, 0xA23F3FAF, 0x96D89736, 0x857A0F41,
+ 0x620305BC, 0x71A19DCB, 0x45463552, 0x56E4AD25,
+ 0x2C896460, 0x3F2BFC17, 0x0BCC548E, 0x186ECCF9,
+ 0xC0D23785, 0xD370AFF2, 0xE797076B, 0xF4359F1C,
+ 0x8E585659, 0x9DFACE2E, 0xA91D66B7, 0xBABFFEC0,
+ 0x5DC6F43D, 0x4E646C4A, 0x7A83C4D3, 0x69215CA4,
+ 0x134C95E1, 0x00EE0D96, 0x3409A50F, 0x27AB3D78,
+ 0x809C2506, 0x933EBD71, 0xA7D915E8, 0xB47B8D9F,
+ 0xCE1644DA, 0xDDB4DCAD, 0xE9537434, 0xFAF1EC43,
+ 0x1D88E6BE, 0x0E2A7EC9, 0x3ACDD650, 0x296F4E27,
+ 0x53028762, 0x40A01F15, 0x7447B78C, 0x67E52FFB,
+ 0xBF59D487, 0xACFB4CF0, 0x981CE469, 0x8BBE7C1E,
+ 0xF1D3B55B, 0xE2712D2C, 0xD69685B5, 0xC5341DC2,
+ 0x224D173F, 0x31EF8F48, 0x050827D1, 0x16AABFA6,
+ 0x6CC776E3, 0x7F65EE94, 0x4B82460D, 0x5820DE7A,
+ 0xFBC3FAF9, 0xE861628E, 0xDC86CA17, 0xCF245260,
+ 0xB5499B25, 0xA6EB0352, 0x920CABCB, 0x81AE33BC,
+ 0x66D73941, 0x7575A136, 0x419209AF, 0x523091D8,
+ 0x285D589D, 0x3BFFC0EA, 0x0F186873, 0x1CBAF004,
+ 0xC4060B78, 0xD7A4930F, 0xE3433B96, 0xF0E1A3E1,
+ 0x8A8C6AA4, 0x992EF2D3, 0xADC95A4A, 0xBE6BC23D,
+ 0x5912C8C0, 0x4AB050B7, 0x7E57F82E, 0x6DF56059,
+ 0x1798A91C, 0x043A316B, 0x30DD99F2, 0x237F0185,
+ 0x844819FB, 0x97EA818C, 0xA30D2915, 0xB0AFB162,
+ 0xCAC27827, 0xD960E050, 0xED8748C9, 0xFE25D0BE,
+ 0x195CDA43, 0x0AFE4234, 0x3E19EAAD, 0x2DBB72DA,
+ 0x57D6BB9F, 0x447423E8, 0x70938B71, 0x63311306,
+ 0xBB8DE87A, 0xA82F700D, 0x9CC8D894, 0x8F6A40E3,
+ 0xF50789A6, 0xE6A511D1, 0xD242B948, 0xC1E0213F,
+ 0x26992BC2, 0x353BB3B5, 0x01DC1B2C, 0x127E835B,
+ 0x68134A1E, 0x7BB1D269, 0x4F567AF0, 0x5CF4E287,
+ 0x04D43CFD, 0x1776A48A, 0x23910C13, 0x30339464,
+ 0x4A5E5D21, 0x59FCC556, 0x6D1B6DCF, 0x7EB9F5B8,
+ 0x99C0FF45, 0x8A626732, 0xBE85CFAB, 0xAD2757DC,
+ 0xD74A9E99, 0xC4E806EE, 0xF00FAE77, 0xE3AD3600,
+ 0x3B11CD7C, 0x28B3550B, 0x1C54FD92, 0x0FF665E5,
+ 0x759BACA0, 0x663934D7, 0x52DE9C4E, 0x417C0439,
+ 0xA6050EC4, 0xB5A796B3, 0x81403E2A, 0x92E2A65D,
+ 0xE88F6F18, 0xFB2DF76F, 0xCFCA5FF6, 0xDC68C781,
+ 0x7B5FDFFF, 0x68FD4788, 0x5C1AEF11, 0x4FB87766,
+ 0x35D5BE23, 0x26772654, 0x12908ECD, 0x013216BA,
+ 0xE64B1C47, 0xF5E98430, 0xC10E2CA9, 0xD2ACB4DE,
+ 0xA8C17D9B, 0xBB63E5EC, 0x8F844D75, 0x9C26D502,
+ 0x449A2E7E, 0x5738B609, 0x63DF1E90, 0x707D86E7,
+ 0x0A104FA2, 0x19B2D7D5, 0x2D557F4C, 0x3EF7E73B,
+ 0xD98EEDC6, 0xCA2C75B1, 0xFECBDD28, 0xED69455F,
+ 0x97048C1A, 0x84A6146D, 0xB041BCF4, 0xA3E32483
+};
+const uint32_t CRC32C_T8_2[256] = {
+ 0x00000000, 0xA541927E, 0x4F6F520D, 0xEA2EC073,
+ 0x9EDEA41A, 0x3B9F3664, 0xD1B1F617, 0x74F06469,
+ 0x38513EC5, 0x9D10ACBB, 0x773E6CC8, 0xD27FFEB6,
+ 0xA68F9ADF, 0x03CE08A1, 0xE9E0C8D2, 0x4CA15AAC,
+ 0x70A27D8A, 0xD5E3EFF4, 0x3FCD2F87, 0x9A8CBDF9,
+ 0xEE7CD990, 0x4B3D4BEE, 0xA1138B9D, 0x045219E3,
+ 0x48F3434F, 0xEDB2D131, 0x079C1142, 0xA2DD833C,
+ 0xD62DE755, 0x736C752B, 0x9942B558, 0x3C032726,
+ 0xE144FB14, 0x4405696A, 0xAE2BA919, 0x0B6A3B67,
+ 0x7F9A5F0E, 0xDADBCD70, 0x30F50D03, 0x95B49F7D,
+ 0xD915C5D1, 0x7C5457AF, 0x967A97DC, 0x333B05A2,
+ 0x47CB61CB, 0xE28AF3B5, 0x08A433C6, 0xADE5A1B8,
+ 0x91E6869E, 0x34A714E0, 0xDE89D493, 0x7BC846ED,
+ 0x0F382284, 0xAA79B0FA, 0x40577089, 0xE516E2F7,
+ 0xA9B7B85B, 0x0CF62A25, 0xE6D8EA56, 0x43997828,
+ 0x37691C41, 0x92288E3F, 0x78064E4C, 0xDD47DC32,
+ 0xC76580D9, 0x622412A7, 0x880AD2D4, 0x2D4B40AA,
+ 0x59BB24C3, 0xFCFAB6BD, 0x16D476CE, 0xB395E4B0,
+ 0xFF34BE1C, 0x5A752C62, 0xB05BEC11, 0x151A7E6F,
+ 0x61EA1A06, 0xC4AB8878, 0x2E85480B, 0x8BC4DA75,
+ 0xB7C7FD53, 0x12866F2D, 0xF8A8AF5E, 0x5DE93D20,
+ 0x29195949, 0x8C58CB37, 0x66760B44, 0xC337993A,
+ 0x8F96C396, 0x2AD751E8, 0xC0F9919B, 0x65B803E5,
+ 0x1148678C, 0xB409F5F2, 0x5E273581, 0xFB66A7FF,
+ 0x26217BCD, 0x8360E9B3, 0x694E29C0, 0xCC0FBBBE,
+ 0xB8FFDFD7, 0x1DBE4DA9, 0xF7908DDA, 0x52D11FA4,
+ 0x1E704508, 0xBB31D776, 0x511F1705, 0xF45E857B,
+ 0x80AEE112, 0x25EF736C, 0xCFC1B31F, 0x6A802161,
+ 0x56830647, 0xF3C29439, 0x19EC544A, 0xBCADC634,
+ 0xC85DA25D, 0x6D1C3023, 0x8732F050, 0x2273622E,
+ 0x6ED23882, 0xCB93AAFC, 0x21BD6A8F, 0x84FCF8F1,
+ 0xF00C9C98, 0x554D0EE6, 0xBF63CE95, 0x1A225CEB,
+ 0x8B277743, 0x2E66E53D, 0xC448254E, 0x6109B730,
+ 0x15F9D359, 0xB0B84127, 0x5A968154, 0xFFD7132A,
+ 0xB3764986, 0x1637DBF8, 0xFC191B8B, 0x595889F5,
+ 0x2DA8ED9C, 0x88E97FE2, 0x62C7BF91, 0xC7862DEF,
+ 0xFB850AC9, 0x5EC498B7, 0xB4EA58C4, 0x11ABCABA,
+ 0x655BAED3, 0xC01A3CAD, 0x2A34FCDE, 0x8F756EA0,
+ 0xC3D4340C, 0x6695A672, 0x8CBB6601, 0x29FAF47F,
+ 0x5D0A9016, 0xF84B0268, 0x1265C21B, 0xB7245065,
+ 0x6A638C57, 0xCF221E29, 0x250CDE5A, 0x804D4C24,
+ 0xF4BD284D, 0x51FCBA33, 0xBBD27A40, 0x1E93E83E,
+ 0x5232B292, 0xF77320EC, 0x1D5DE09F, 0xB81C72E1,
+ 0xCCEC1688, 0x69AD84F6, 0x83834485, 0x26C2D6FB,
+ 0x1AC1F1DD, 0xBF8063A3, 0x55AEA3D0, 0xF0EF31AE,
+ 0x841F55C7, 0x215EC7B9, 0xCB7007CA, 0x6E3195B4,
+ 0x2290CF18, 0x87D15D66, 0x6DFF9D15, 0xC8BE0F6B,
+ 0xBC4E6B02, 0x190FF97C, 0xF321390F, 0x5660AB71,
+ 0x4C42F79A, 0xE90365E4, 0x032DA597, 0xA66C37E9,
+ 0xD29C5380, 0x77DDC1FE, 0x9DF3018D, 0x38B293F3,
+ 0x7413C95F, 0xD1525B21, 0x3B7C9B52, 0x9E3D092C,
+ 0xEACD6D45, 0x4F8CFF3B, 0xA5A23F48, 0x00E3AD36,
+ 0x3CE08A10, 0x99A1186E, 0x738FD81D, 0xD6CE4A63,
+ 0xA23E2E0A, 0x077FBC74, 0xED517C07, 0x4810EE79,
+ 0x04B1B4D5, 0xA1F026AB, 0x4BDEE6D8, 0xEE9F74A6,
+ 0x9A6F10CF, 0x3F2E82B1, 0xD50042C2, 0x7041D0BC,
+ 0xAD060C8E, 0x08479EF0, 0xE2695E83, 0x4728CCFD,
+ 0x33D8A894, 0x96993AEA, 0x7CB7FA99, 0xD9F668E7,
+ 0x9557324B, 0x3016A035, 0xDA386046, 0x7F79F238,
+ 0x0B899651, 0xAEC8042F, 0x44E6C45C, 0xE1A75622,
+ 0xDDA47104, 0x78E5E37A, 0x92CB2309, 0x378AB177,
+ 0x437AD51E, 0xE63B4760, 0x0C158713, 0xA954156D,
+ 0xE5F54FC1, 0x40B4DDBF, 0xAA9A1DCC, 0x0FDB8FB2,
+ 0x7B2BEBDB, 0xDE6A79A5, 0x3444B9D6, 0x91052BA8
+};
+const uint32_t CRC32C_T8_3[256] = {
+ 0x00000000, 0xDD45AAB8, 0xBF672381, 0x62228939,
+ 0x7B2231F3, 0xA6679B4B, 0xC4451272, 0x1900B8CA,
+ 0xF64463E6, 0x2B01C95E, 0x49234067, 0x9466EADF,
+ 0x8D665215, 0x5023F8AD, 0x32017194, 0xEF44DB2C,
+ 0xE964B13D, 0x34211B85, 0x560392BC, 0x8B463804,
+ 0x924680CE, 0x4F032A76, 0x2D21A34F, 0xF06409F7,
+ 0x1F20D2DB, 0xC2657863, 0xA047F15A, 0x7D025BE2,
+ 0x6402E328, 0xB9474990, 0xDB65C0A9, 0x06206A11,
+ 0xD725148B, 0x0A60BE33, 0x6842370A, 0xB5079DB2,
+ 0xAC072578, 0x71428FC0, 0x136006F9, 0xCE25AC41,
+ 0x2161776D, 0xFC24DDD5, 0x9E0654EC, 0x4343FE54,
+ 0x5A43469E, 0x8706EC26, 0xE524651F, 0x3861CFA7,
+ 0x3E41A5B6, 0xE3040F0E, 0x81268637, 0x5C632C8F,
+ 0x45639445, 0x98263EFD, 0xFA04B7C4, 0x27411D7C,
+ 0xC805C650, 0x15406CE8, 0x7762E5D1, 0xAA274F69,
+ 0xB327F7A3, 0x6E625D1B, 0x0C40D422, 0xD1057E9A,
+ 0xABA65FE7, 0x76E3F55F, 0x14C17C66, 0xC984D6DE,
+ 0xD0846E14, 0x0DC1C4AC, 0x6FE34D95, 0xB2A6E72D,
+ 0x5DE23C01, 0x80A796B9, 0xE2851F80, 0x3FC0B538,
+ 0x26C00DF2, 0xFB85A74A, 0x99A72E73, 0x44E284CB,
+ 0x42C2EEDA, 0x9F874462, 0xFDA5CD5B, 0x20E067E3,
+ 0x39E0DF29, 0xE4A57591, 0x8687FCA8, 0x5BC25610,
+ 0xB4868D3C, 0x69C32784, 0x0BE1AEBD, 0xD6A40405,
+ 0xCFA4BCCF, 0x12E11677, 0x70C39F4E, 0xAD8635F6,
+ 0x7C834B6C, 0xA1C6E1D4, 0xC3E468ED, 0x1EA1C255,
+ 0x07A17A9F, 0xDAE4D027, 0xB8C6591E, 0x6583F3A6,
+ 0x8AC7288A, 0x57828232, 0x35A00B0B, 0xE8E5A1B3,
+ 0xF1E51979, 0x2CA0B3C1, 0x4E823AF8, 0x93C79040,
+ 0x95E7FA51, 0x48A250E9, 0x2A80D9D0, 0xF7C57368,
+ 0xEEC5CBA2, 0x3380611A, 0x51A2E823, 0x8CE7429B,
+ 0x63A399B7, 0xBEE6330F, 0xDCC4BA36, 0x0181108E,
+ 0x1881A844, 0xC5C402FC, 0xA7E68BC5, 0x7AA3217D,
+ 0x52A0C93F, 0x8FE56387, 0xEDC7EABE, 0x30824006,
+ 0x2982F8CC, 0xF4C75274, 0x96E5DB4D, 0x4BA071F5,
+ 0xA4E4AAD9, 0x79A10061, 0x1B838958, 0xC6C623E0,
+ 0xDFC69B2A, 0x02833192, 0x60A1B8AB, 0xBDE41213,
+ 0xBBC47802, 0x6681D2BA, 0x04A35B83, 0xD9E6F13B,
+ 0xC0E649F1, 0x1DA3E349, 0x7F816A70, 0xA2C4C0C8,
+ 0x4D801BE4, 0x90C5B15C, 0xF2E73865, 0x2FA292DD,
+ 0x36A22A17, 0xEBE780AF, 0x89C50996, 0x5480A32E,
+ 0x8585DDB4, 0x58C0770C, 0x3AE2FE35, 0xE7A7548D,
+ 0xFEA7EC47, 0x23E246FF, 0x41C0CFC6, 0x9C85657E,
+ 0x73C1BE52, 0xAE8414EA, 0xCCA69DD3, 0x11E3376B,
+ 0x08E38FA1, 0xD5A62519, 0xB784AC20, 0x6AC10698,
+ 0x6CE16C89, 0xB1A4C631, 0xD3864F08, 0x0EC3E5B0,
+ 0x17C35D7A, 0xCA86F7C2, 0xA8A47EFB, 0x75E1D443,
+ 0x9AA50F6F, 0x47E0A5D7, 0x25C22CEE, 0xF8878656,
+ 0xE1873E9C, 0x3CC29424, 0x5EE01D1D, 0x83A5B7A5,
+ 0xF90696D8, 0x24433C60, 0x4661B559, 0x9B241FE1,
+ 0x8224A72B, 0x5F610D93, 0x3D4384AA, 0xE0062E12,
+ 0x0F42F53E, 0xD2075F86, 0xB025D6BF, 0x6D607C07,
+ 0x7460C4CD, 0xA9256E75, 0xCB07E74C, 0x16424DF4,
+ 0x106227E5, 0xCD278D5D, 0xAF050464, 0x7240AEDC,
+ 0x6B401616, 0xB605BCAE, 0xD4273597, 0x09629F2F,
+ 0xE6264403, 0x3B63EEBB, 0x59416782, 0x8404CD3A,
+ 0x9D0475F0, 0x4041DF48, 0x22635671, 0xFF26FCC9,
+ 0x2E238253, 0xF36628EB, 0x9144A1D2, 0x4C010B6A,
+ 0x5501B3A0, 0x88441918, 0xEA669021, 0x37233A99,
+ 0xD867E1B5, 0x05224B0D, 0x6700C234, 0xBA45688C,
+ 0xA345D046, 0x7E007AFE, 0x1C22F3C7, 0xC167597F,
+ 0xC747336E, 0x1A0299D6, 0x782010EF, 0xA565BA57,
+ 0xBC65029D, 0x6120A825, 0x0302211C, 0xDE478BA4,
+ 0x31035088, 0xEC46FA30, 0x8E647309, 0x5321D9B1,
+ 0x4A21617B, 0x9764CBC3, 0xF54642FA, 0x2803E842
+};
+const uint32_t CRC32C_T8_4[256] = {
+ 0x00000000, 0x38116FAC, 0x7022DF58, 0x4833B0F4,
+ 0xE045BEB0, 0xD854D11C, 0x906761E8, 0xA8760E44,
+ 0xC5670B91, 0xFD76643D, 0xB545D4C9, 0x8D54BB65,
+ 0x2522B521, 0x1D33DA8D, 0x55006A79, 0x6D1105D5,
+ 0x8F2261D3, 0xB7330E7F, 0xFF00BE8B, 0xC711D127,
+ 0x6F67DF63, 0x5776B0CF, 0x1F45003B, 0x27546F97,
+ 0x4A456A42, 0x725405EE, 0x3A67B51A, 0x0276DAB6,
+ 0xAA00D4F2, 0x9211BB5E, 0xDA220BAA, 0xE2336406,
+ 0x1BA8B557, 0x23B9DAFB, 0x6B8A6A0F, 0x539B05A3,
+ 0xFBED0BE7, 0xC3FC644B, 0x8BCFD4BF, 0xB3DEBB13,
+ 0xDECFBEC6, 0xE6DED16A, 0xAEED619E, 0x96FC0E32,
+ 0x3E8A0076, 0x069B6FDA, 0x4EA8DF2E, 0x76B9B082,
+ 0x948AD484, 0xAC9BBB28, 0xE4A80BDC, 0xDCB96470,
+ 0x74CF6A34, 0x4CDE0598, 0x04EDB56C, 0x3CFCDAC0,
+ 0x51EDDF15, 0x69FCB0B9, 0x21CF004D, 0x19DE6FE1,
+ 0xB1A861A5, 0x89B90E09, 0xC18ABEFD, 0xF99BD151,
+ 0x37516AAE, 0x0F400502, 0x4773B5F6, 0x7F62DA5A,
+ 0xD714D41E, 0xEF05BBB2, 0xA7360B46, 0x9F2764EA,
+ 0xF236613F, 0xCA270E93, 0x8214BE67, 0xBA05D1CB,
+ 0x1273DF8F, 0x2A62B023, 0x625100D7, 0x5A406F7B,
+ 0xB8730B7D, 0x806264D1, 0xC851D425, 0xF040BB89,
+ 0x5836B5CD, 0x6027DA61, 0x28146A95, 0x10050539,
+ 0x7D1400EC, 0x45056F40, 0x0D36DFB4, 0x3527B018,
+ 0x9D51BE5C, 0xA540D1F0, 0xED736104, 0xD5620EA8,
+ 0x2CF9DFF9, 0x14E8B055, 0x5CDB00A1, 0x64CA6F0D,
+ 0xCCBC6149, 0xF4AD0EE5, 0xBC9EBE11, 0x848FD1BD,
+ 0xE99ED468, 0xD18FBBC4, 0x99BC0B30, 0xA1AD649C,
+ 0x09DB6AD8, 0x31CA0574, 0x79F9B580, 0x41E8DA2C,
+ 0xA3DBBE2A, 0x9BCAD186, 0xD3F96172, 0xEBE80EDE,
+ 0x439E009A, 0x7B8F6F36, 0x33BCDFC2, 0x0BADB06E,
+ 0x66BCB5BB, 0x5EADDA17, 0x169E6AE3, 0x2E8F054F,
+ 0x86F90B0B, 0xBEE864A7, 0xF6DBD453, 0xCECABBFF,
+ 0x6EA2D55C, 0x56B3BAF0, 0x1E800A04, 0x269165A8,
+ 0x8EE76BEC, 0xB6F60440, 0xFEC5B4B4, 0xC6D4DB18,
+ 0xABC5DECD, 0x93D4B161, 0xDBE70195, 0xE3F66E39,
+ 0x4B80607D, 0x73910FD1, 0x3BA2BF25, 0x03B3D089,
+ 0xE180B48F, 0xD991DB23, 0x91A26BD7, 0xA9B3047B,
+ 0x01C50A3F, 0x39D46593, 0x71E7D567, 0x49F6BACB,
+ 0x24E7BF1E, 0x1CF6D0B2, 0x54C56046, 0x6CD40FEA,
+ 0xC4A201AE, 0xFCB36E02, 0xB480DEF6, 0x8C91B15A,
+ 0x750A600B, 0x4D1B0FA7, 0x0528BF53, 0x3D39D0FF,
+ 0x954FDEBB, 0xAD5EB117, 0xE56D01E3, 0xDD7C6E4F,
+ 0xB06D6B9A, 0x887C0436, 0xC04FB4C2, 0xF85EDB6E,
+ 0x5028D52A, 0x6839BA86, 0x200A0A72, 0x181B65DE,
+ 0xFA2801D8, 0xC2396E74, 0x8A0ADE80, 0xB21BB12C,
+ 0x1A6DBF68, 0x227CD0C4, 0x6A4F6030, 0x525E0F9C,
+ 0x3F4F0A49, 0x075E65E5, 0x4F6DD511, 0x777CBABD,
+ 0xDF0AB4F9, 0xE71BDB55, 0xAF286BA1, 0x9739040D,
+ 0x59F3BFF2, 0x61E2D05E, 0x29D160AA, 0x11C00F06,
+ 0xB9B60142, 0x81A76EEE, 0xC994DE1A, 0xF185B1B6,
+ 0x9C94B463, 0xA485DBCF, 0xECB66B3B, 0xD4A70497,
+ 0x7CD10AD3, 0x44C0657F, 0x0CF3D58B, 0x34E2BA27,
+ 0xD6D1DE21, 0xEEC0B18D, 0xA6F30179, 0x9EE26ED5,
+ 0x36946091, 0x0E850F3D, 0x46B6BFC9, 0x7EA7D065,
+ 0x13B6D5B0, 0x2BA7BA1C, 0x63940AE8, 0x5B856544,
+ 0xF3F36B00, 0xCBE204AC, 0x83D1B458, 0xBBC0DBF4,
+ 0x425B0AA5, 0x7A4A6509, 0x3279D5FD, 0x0A68BA51,
+ 0xA21EB415, 0x9A0FDBB9, 0xD23C6B4D, 0xEA2D04E1,
+ 0x873C0134, 0xBF2D6E98, 0xF71EDE6C, 0xCF0FB1C0,
+ 0x6779BF84, 0x5F68D028, 0x175B60DC, 0x2F4A0F70,
+ 0xCD796B76, 0xF56804DA, 0xBD5BB42E, 0x854ADB82,
+ 0x2D3CD5C6, 0x152DBA6A, 0x5D1E0A9E, 0x650F6532,
+ 0x081E60E7, 0x300F0F4B, 0x783CBFBF, 0x402DD013,
+ 0xE85BDE57, 0xD04AB1FB, 0x9879010F, 0xA0686EA3
+};
+const uint32_t CRC32C_T8_5[256] = {
+ 0x00000000, 0xEF306B19, 0xDB8CA0C3, 0x34BCCBDA,
+ 0xB2F53777, 0x5DC55C6E, 0x697997B4, 0x8649FCAD,
+ 0x6006181F, 0x8F367306, 0xBB8AB8DC, 0x54BAD3C5,
+ 0xD2F32F68, 0x3DC34471, 0x097F8FAB, 0xE64FE4B2,
+ 0xC00C303E, 0x2F3C5B27, 0x1B8090FD, 0xF4B0FBE4,
+ 0x72F90749, 0x9DC96C50, 0xA975A78A, 0x4645CC93,
+ 0xA00A2821, 0x4F3A4338, 0x7B8688E2, 0x94B6E3FB,
+ 0x12FF1F56, 0xFDCF744F, 0xC973BF95, 0x2643D48C,
+ 0x85F4168D, 0x6AC47D94, 0x5E78B64E, 0xB148DD57,
+ 0x370121FA, 0xD8314AE3, 0xEC8D8139, 0x03BDEA20,
+ 0xE5F20E92, 0x0AC2658B, 0x3E7EAE51, 0xD14EC548,
+ 0x570739E5, 0xB83752FC, 0x8C8B9926, 0x63BBF23F,
+ 0x45F826B3, 0xAAC84DAA, 0x9E748670, 0x7144ED69,
+ 0xF70D11C4, 0x183D7ADD, 0x2C81B107, 0xC3B1DA1E,
+ 0x25FE3EAC, 0xCACE55B5, 0xFE729E6F, 0x1142F576,
+ 0x970B09DB, 0x783B62C2, 0x4C87A918, 0xA3B7C201,
+ 0x0E045BEB, 0xE13430F2, 0xD588FB28, 0x3AB89031,
+ 0xBCF16C9C, 0x53C10785, 0x677DCC5F, 0x884DA746,
+ 0x6E0243F4, 0x813228ED, 0xB58EE337, 0x5ABE882E,
+ 0xDCF77483, 0x33C71F9A, 0x077BD440, 0xE84BBF59,
+ 0xCE086BD5, 0x213800CC, 0x1584CB16, 0xFAB4A00F,
+ 0x7CFD5CA2, 0x93CD37BB, 0xA771FC61, 0x48419778,
+ 0xAE0E73CA, 0x413E18D3, 0x7582D309, 0x9AB2B810,
+ 0x1CFB44BD, 0xF3CB2FA4, 0xC777E47E, 0x28478F67,
+ 0x8BF04D66, 0x64C0267F, 0x507CEDA5, 0xBF4C86BC,
+ 0x39057A11, 0xD6351108, 0xE289DAD2, 0x0DB9B1CB,
+ 0xEBF65579, 0x04C63E60, 0x307AF5BA, 0xDF4A9EA3,
+ 0x5903620E, 0xB6330917, 0x828FC2CD, 0x6DBFA9D4,
+ 0x4BFC7D58, 0xA4CC1641, 0x9070DD9B, 0x7F40B682,
+ 0xF9094A2F, 0x16392136, 0x2285EAEC, 0xCDB581F5,
+ 0x2BFA6547, 0xC4CA0E5E, 0xF076C584, 0x1F46AE9D,
+ 0x990F5230, 0x763F3929, 0x4283F2F3, 0xADB399EA,
+ 0x1C08B7D6, 0xF338DCCF, 0xC7841715, 0x28B47C0C,
+ 0xAEFD80A1, 0x41CDEBB8, 0x75712062, 0x9A414B7B,
+ 0x7C0EAFC9, 0x933EC4D0, 0xA7820F0A, 0x48B26413,
+ 0xCEFB98BE, 0x21CBF3A7, 0x1577387D, 0xFA475364,
+ 0xDC0487E8, 0x3334ECF1, 0x0788272B, 0xE8B84C32,
+ 0x6EF1B09F, 0x81C1DB86, 0xB57D105C, 0x5A4D7B45,
+ 0xBC029FF7, 0x5332F4EE, 0x678E3F34, 0x88BE542D,
+ 0x0EF7A880, 0xE1C7C399, 0xD57B0843, 0x3A4B635A,
+ 0x99FCA15B, 0x76CCCA42, 0x42700198, 0xAD406A81,
+ 0x2B09962C, 0xC439FD35, 0xF08536EF, 0x1FB55DF6,
+ 0xF9FAB944, 0x16CAD25D, 0x22761987, 0xCD46729E,
+ 0x4B0F8E33, 0xA43FE52A, 0x90832EF0, 0x7FB345E9,
+ 0x59F09165, 0xB6C0FA7C, 0x827C31A6, 0x6D4C5ABF,
+ 0xEB05A612, 0x0435CD0B, 0x308906D1, 0xDFB96DC8,
+ 0x39F6897A, 0xD6C6E263, 0xE27A29B9, 0x0D4A42A0,
+ 0x8B03BE0D, 0x6433D514, 0x508F1ECE, 0xBFBF75D7,
+ 0x120CEC3D, 0xFD3C8724, 0xC9804CFE, 0x26B027E7,
+ 0xA0F9DB4A, 0x4FC9B053, 0x7B757B89, 0x94451090,
+ 0x720AF422, 0x9D3A9F3B, 0xA98654E1, 0x46B63FF8,
+ 0xC0FFC355, 0x2FCFA84C, 0x1B736396, 0xF443088F,
+ 0xD200DC03, 0x3D30B71A, 0x098C7CC0, 0xE6BC17D9,
+ 0x60F5EB74, 0x8FC5806D, 0xBB794BB7, 0x544920AE,
+ 0xB206C41C, 0x5D36AF05, 0x698A64DF, 0x86BA0FC6,
+ 0x00F3F36B, 0xEFC39872, 0xDB7F53A8, 0x344F38B1,
+ 0x97F8FAB0, 0x78C891A9, 0x4C745A73, 0xA344316A,
+ 0x250DCDC7, 0xCA3DA6DE, 0xFE816D04, 0x11B1061D,
+ 0xF7FEE2AF, 0x18CE89B6, 0x2C72426C, 0xC3422975,
+ 0x450BD5D8, 0xAA3BBEC1, 0x9E87751B, 0x71B71E02,
+ 0x57F4CA8E, 0xB8C4A197, 0x8C786A4D, 0x63480154,
+ 0xE501FDF9, 0x0A3196E0, 0x3E8D5D3A, 0xD1BD3623,
+ 0x37F2D291, 0xD8C2B988, 0xEC7E7252, 0x034E194B,
+ 0x8507E5E6, 0x6A378EFF, 0x5E8B4525, 0xB1BB2E3C
+};
+const uint32_t CRC32C_T8_6[256] = {
+ 0x00000000, 0x68032CC8, 0xD0065990, 0xB8057558,
+ 0xA5E0C5D1, 0xCDE3E919, 0x75E69C41, 0x1DE5B089,
+ 0x4E2DFD53, 0x262ED19B, 0x9E2BA4C3, 0xF628880B,
+ 0xEBCD3882, 0x83CE144A, 0x3BCB6112, 0x53C84DDA,
+ 0x9C5BFAA6, 0xF458D66E, 0x4C5DA336, 0x245E8FFE,
+ 0x39BB3F77, 0x51B813BF, 0xE9BD66E7, 0x81BE4A2F,
+ 0xD27607F5, 0xBA752B3D, 0x02705E65, 0x6A7372AD,
+ 0x7796C224, 0x1F95EEEC, 0xA7909BB4, 0xCF93B77C,
+ 0x3D5B83BD, 0x5558AF75, 0xED5DDA2D, 0x855EF6E5,
+ 0x98BB466C, 0xF0B86AA4, 0x48BD1FFC, 0x20BE3334,
+ 0x73767EEE, 0x1B755226, 0xA370277E, 0xCB730BB6,
+ 0xD696BB3F, 0xBE9597F7, 0x0690E2AF, 0x6E93CE67,
+ 0xA100791B, 0xC90355D3, 0x7106208B, 0x19050C43,
+ 0x04E0BCCA, 0x6CE39002, 0xD4E6E55A, 0xBCE5C992,
+ 0xEF2D8448, 0x872EA880, 0x3F2BDDD8, 0x5728F110,
+ 0x4ACD4199, 0x22CE6D51, 0x9ACB1809, 0xF2C834C1,
+ 0x7AB7077A, 0x12B42BB2, 0xAAB15EEA, 0xC2B27222,
+ 0xDF57C2AB, 0xB754EE63, 0x0F519B3B, 0x6752B7F3,
+ 0x349AFA29, 0x5C99D6E1, 0xE49CA3B9, 0x8C9F8F71,
+ 0x917A3FF8, 0xF9791330, 0x417C6668, 0x297F4AA0,
+ 0xE6ECFDDC, 0x8EEFD114, 0x36EAA44C, 0x5EE98884,
+ 0x430C380D, 0x2B0F14C5, 0x930A619D, 0xFB094D55,
+ 0xA8C1008F, 0xC0C22C47, 0x78C7591F, 0x10C475D7,
+ 0x0D21C55E, 0x6522E996, 0xDD279CCE, 0xB524B006,
+ 0x47EC84C7, 0x2FEFA80F, 0x97EADD57, 0xFFE9F19F,
+ 0xE20C4116, 0x8A0F6DDE, 0x320A1886, 0x5A09344E,
+ 0x09C17994, 0x61C2555C, 0xD9C72004, 0xB1C40CCC,
+ 0xAC21BC45, 0xC422908D, 0x7C27E5D5, 0x1424C91D,
+ 0xDBB77E61, 0xB3B452A9, 0x0BB127F1, 0x63B20B39,
+ 0x7E57BBB0, 0x16549778, 0xAE51E220, 0xC652CEE8,
+ 0x959A8332, 0xFD99AFFA, 0x459CDAA2, 0x2D9FF66A,
+ 0x307A46E3, 0x58796A2B, 0xE07C1F73, 0x887F33BB,
+ 0xF56E0EF4, 0x9D6D223C, 0x25685764, 0x4D6B7BAC,
+ 0x508ECB25, 0x388DE7ED, 0x808892B5, 0xE88BBE7D,
+ 0xBB43F3A7, 0xD340DF6F, 0x6B45AA37, 0x034686FF,
+ 0x1EA33676, 0x76A01ABE, 0xCEA56FE6, 0xA6A6432E,
+ 0x6935F452, 0x0136D89A, 0xB933ADC2, 0xD130810A,
+ 0xCCD53183, 0xA4D61D4B, 0x1CD36813, 0x74D044DB,
+ 0x27180901, 0x4F1B25C9, 0xF71E5091, 0x9F1D7C59,
+ 0x82F8CCD0, 0xEAFBE018, 0x52FE9540, 0x3AFDB988,
+ 0xC8358D49, 0xA036A181, 0x1833D4D9, 0x7030F811,
+ 0x6DD54898, 0x05D66450, 0xBDD31108, 0xD5D03DC0,
+ 0x8618701A, 0xEE1B5CD2, 0x561E298A, 0x3E1D0542,
+ 0x23F8B5CB, 0x4BFB9903, 0xF3FEEC5B, 0x9BFDC093,
+ 0x546E77EF, 0x3C6D5B27, 0x84682E7F, 0xEC6B02B7,
+ 0xF18EB23E, 0x998D9EF6, 0x2188EBAE, 0x498BC766,
+ 0x1A438ABC, 0x7240A674, 0xCA45D32C, 0xA246FFE4,
+ 0xBFA34F6D, 0xD7A063A5, 0x6FA516FD, 0x07A63A35,
+ 0x8FD9098E, 0xE7DA2546, 0x5FDF501E, 0x37DC7CD6,
+ 0x2A39CC5F, 0x423AE097, 0xFA3F95CF, 0x923CB907,
+ 0xC1F4F4DD, 0xA9F7D815, 0x11F2AD4D, 0x79F18185,
+ 0x6414310C, 0x0C171DC4, 0xB412689C, 0xDC114454,
+ 0x1382F328, 0x7B81DFE0, 0xC384AAB8, 0xAB878670,
+ 0xB66236F9, 0xDE611A31, 0x66646F69, 0x0E6743A1,
+ 0x5DAF0E7B, 0x35AC22B3, 0x8DA957EB, 0xE5AA7B23,
+ 0xF84FCBAA, 0x904CE762, 0x2849923A, 0x404ABEF2,
+ 0xB2828A33, 0xDA81A6FB, 0x6284D3A3, 0x0A87FF6B,
+ 0x17624FE2, 0x7F61632A, 0xC7641672, 0xAF673ABA,
+ 0xFCAF7760, 0x94AC5BA8, 0x2CA92EF0, 0x44AA0238,
+ 0x594FB2B1, 0x314C9E79, 0x8949EB21, 0xE14AC7E9,
+ 0x2ED97095, 0x46DA5C5D, 0xFEDF2905, 0x96DC05CD,
+ 0x8B39B544, 0xE33A998C, 0x5B3FECD4, 0x333CC01C,
+ 0x60F48DC6, 0x08F7A10E, 0xB0F2D456, 0xD8F1F89E,
+ 0xC5144817, 0xAD1764DF, 0x15121187, 0x7D113D4F
+};
+const uint32_t CRC32C_T8_7[256] = {
+ 0x00000000, 0x493C7D27, 0x9278FA4E, 0xDB448769,
+ 0x211D826D, 0x6821FF4A, 0xB3657823, 0xFA590504,
+ 0x423B04DA, 0x0B0779FD, 0xD043FE94, 0x997F83B3,
+ 0x632686B7, 0x2A1AFB90, 0xF15E7CF9, 0xB86201DE,
+ 0x847609B4, 0xCD4A7493, 0x160EF3FA, 0x5F328EDD,
+ 0xA56B8BD9, 0xEC57F6FE, 0x37137197, 0x7E2F0CB0,
+ 0xC64D0D6E, 0x8F717049, 0x5435F720, 0x1D098A07,
+ 0xE7508F03, 0xAE6CF224, 0x7528754D, 0x3C14086A,
+ 0x0D006599, 0x443C18BE, 0x9F789FD7, 0xD644E2F0,
+ 0x2C1DE7F4, 0x65219AD3, 0xBE651DBA, 0xF759609D,
+ 0x4F3B6143, 0x06071C64, 0xDD439B0D, 0x947FE62A,
+ 0x6E26E32E, 0x271A9E09, 0xFC5E1960, 0xB5626447,
+ 0x89766C2D, 0xC04A110A, 0x1B0E9663, 0x5232EB44,
+ 0xA86BEE40, 0xE1579367, 0x3A13140E, 0x732F6929,
+ 0xCB4D68F7, 0x827115D0, 0x593592B9, 0x1009EF9E,
+ 0xEA50EA9A, 0xA36C97BD, 0x782810D4, 0x31146DF3,
+ 0x1A00CB32, 0x533CB615, 0x8878317C, 0xC1444C5B,
+ 0x3B1D495F, 0x72213478, 0xA965B311, 0xE059CE36,
+ 0x583BCFE8, 0x1107B2CF, 0xCA4335A6, 0x837F4881,
+ 0x79264D85, 0x301A30A2, 0xEB5EB7CB, 0xA262CAEC,
+ 0x9E76C286, 0xD74ABFA1, 0x0C0E38C8, 0x453245EF,
+ 0xBF6B40EB, 0xF6573DCC, 0x2D13BAA5, 0x642FC782,
+ 0xDC4DC65C, 0x9571BB7B, 0x4E353C12, 0x07094135,
+ 0xFD504431, 0xB46C3916, 0x6F28BE7F, 0x2614C358,
+ 0x1700AEAB, 0x5E3CD38C, 0x857854E5, 0xCC4429C2,
+ 0x361D2CC6, 0x7F2151E1, 0xA465D688, 0xED59ABAF,
+ 0x553BAA71, 0x1C07D756, 0xC743503F, 0x8E7F2D18,
+ 0x7426281C, 0x3D1A553B, 0xE65ED252, 0xAF62AF75,
+ 0x9376A71F, 0xDA4ADA38, 0x010E5D51, 0x48322076,
+ 0xB26B2572, 0xFB575855, 0x2013DF3C, 0x692FA21B,
+ 0xD14DA3C5, 0x9871DEE2, 0x4335598B, 0x0A0924AC,
+ 0xF05021A8, 0xB96C5C8F, 0x6228DBE6, 0x2B14A6C1,
+ 0x34019664, 0x7D3DEB43, 0xA6796C2A, 0xEF45110D,
+ 0x151C1409, 0x5C20692E, 0x8764EE47, 0xCE589360,
+ 0x763A92BE, 0x3F06EF99, 0xE44268F0, 0xAD7E15D7,
+ 0x572710D3, 0x1E1B6DF4, 0xC55FEA9D, 0x8C6397BA,
+ 0xB0779FD0, 0xF94BE2F7, 0x220F659E, 0x6B3318B9,
+ 0x916A1DBD, 0xD856609A, 0x0312E7F3, 0x4A2E9AD4,
+ 0xF24C9B0A, 0xBB70E62D, 0x60346144, 0x29081C63,
+ 0xD3511967, 0x9A6D6440, 0x4129E329, 0x08159E0E,
+ 0x3901F3FD, 0x703D8EDA, 0xAB7909B3, 0xE2457494,
+ 0x181C7190, 0x51200CB7, 0x8A648BDE, 0xC358F6F9,
+ 0x7B3AF727, 0x32068A00, 0xE9420D69, 0xA07E704E,
+ 0x5A27754A, 0x131B086D, 0xC85F8F04, 0x8163F223,
+ 0xBD77FA49, 0xF44B876E, 0x2F0F0007, 0x66337D20,
+ 0x9C6A7824, 0xD5560503, 0x0E12826A, 0x472EFF4D,
+ 0xFF4CFE93, 0xB67083B4, 0x6D3404DD, 0x240879FA,
+ 0xDE517CFE, 0x976D01D9, 0x4C2986B0, 0x0515FB97,
+ 0x2E015D56, 0x673D2071, 0xBC79A718, 0xF545DA3F,
+ 0x0F1CDF3B, 0x4620A21C, 0x9D642575, 0xD4585852,
+ 0x6C3A598C, 0x250624AB, 0xFE42A3C2, 0xB77EDEE5,
+ 0x4D27DBE1, 0x041BA6C6, 0xDF5F21AF, 0x96635C88,
+ 0xAA7754E2, 0xE34B29C5, 0x380FAEAC, 0x7133D38B,
+ 0x8B6AD68F, 0xC256ABA8, 0x19122CC1, 0x502E51E6,
+ 0xE84C5038, 0xA1702D1F, 0x7A34AA76, 0x3308D751,
+ 0xC951D255, 0x806DAF72, 0x5B29281B, 0x1215553C,
+ 0x230138CF, 0x6A3D45E8, 0xB179C281, 0xF845BFA6,
+ 0x021CBAA2, 0x4B20C785, 0x906440EC, 0xD9583DCB,
+ 0x613A3C15, 0x28064132, 0xF342C65B, 0xBA7EBB7C,
+ 0x4027BE78, 0x091BC35F, 0xD25F4436, 0x9B633911,
+ 0xA777317B, 0xEE4B4C5C, 0x350FCB35, 0x7C33B612,
+ 0x866AB316, 0xCF56CE31, 0x14124958, 0x5D2E347F,
+ 0xE54C35A1, 0xAC704886, 0x7734CFEF, 0x3E08B2C8,
+ 0xC451B7CC, 0x8D6DCAEB, 0x56294D82, 0x1F1530A5
+};
diff --git a/ratis-common/src/main/native/src/org/apache/ratis/util/gcc_optimizations.h b/ratis-common/src/main/native/src/org/apache/ratis/util/gcc_optimizations.h
new file mode 100644
index 0000000000..8c0fbffe6a
--- /dev/null
+++ b/ratis-common/src/main/native/src/org/apache/ratis/util/gcc_optimizations.h
@@ -0,0 +1,30 @@
+/*
+ * 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.
+ */
+#ifndef __GCC_OPTIMIZATIONS_H_INCLUDED
+#define __GCC_OPTIMIZATIONS_H_INCLUDED
+
+// Hints to gcc optimizer -- compiled out on non-GCC
+#ifdef __GNUC__
+#define likely(x) __builtin_expect((x),1)
+#define unlikely(x) __builtin_expect((x),0)
+#else
+#define likely(x) (x)
+#define unlikely(x) (x)
+#endif
+
+#endif
diff --git a/ratis-common/src/main/native/src/org_apache_ratis.h b/ratis-common/src/main/native/src/org_apache_ratis.h
new file mode 100644
index 0000000000..0de9c815a3
--- /dev/null
+++ b/ratis-common/src/main/native/src/org_apache_ratis.h
@@ -0,0 +1,189 @@
+/**
+ * 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.
+ */
+
+/**
+ * This file includes some common utilities
+ * for all native code used in ratis.
+ */
+
+#if !defined ORG_APACHE_RATIS_H
+#define ORG_APACHE_RATIS_H
+
+#if defined(_WIN32)
+#undef UNIX
+#define WINDOWS
+#else
+#undef WINDOWS
+#define UNIX
+#endif
+
+/* A helper macro to 'throw' a java exception. */
+#define THROW(env, exception_name, message) \
+ { \
+ jclass ecls = (*env)->FindClass(env, exception_name); \
+ if (ecls) { \
+ (*env)->ThrowNew(env, ecls, message); \
+ (*env)->DeleteLocalRef(env, ecls); \
+ } \
+ }
+
+/* Helper macro to return if an exception is pending */
+#define PASS_EXCEPTIONS(env) \
+ { \
+ if ((*env)->ExceptionCheck(env)) return; \
+ }
+
+#define PASS_EXCEPTIONS_GOTO(env, target) \
+ { \
+ if ((*env)->ExceptionCheck(env)) goto target; \
+ }
+
+#define PASS_EXCEPTIONS_RET(env, ret) \
+ { \
+ if ((*env)->ExceptionCheck(env)) return (ret); \
+ }
+
+/**
+ * Unix definitions
+ */
+#ifdef UNIX
+#include
+#include
+#include
+
+/**
+ * A helper function to dlsym a 'symbol' from a given library-handle.
+ *
+ * @param env jni handle to report contingencies.
+ * @param handle handle to the dlopen'ed library.
+ * @param symbol symbol to load.
+ * @return returns the address where the symbol is loaded in memory,
+ * NULL on error.
+ */
+static __attribute__ ((unused))
+void *do_dlsym(JNIEnv *env, void *handle, const char *symbol) {
+ if (!env || !handle || !symbol) {
+ THROW(env, "java/lang/InternalError", NULL);
+ return NULL;
+ }
+ char *error = NULL;
+ void *func_ptr = dlsym(handle, symbol);
+ if ((error = dlerror()) != NULL) {
+ THROW(env, "java/lang/UnsatisfiedLinkError", symbol);
+ return NULL;
+ }
+ return func_ptr;
+}
+
+/* A helper macro to dlsym the requisite dynamic symbol and bail-out on error. */
+#define LOAD_DYNAMIC_SYMBOL(func_ptr, env, handle, symbol) \
+ if ((func_ptr = do_dlsym(env, handle, symbol)) == NULL) { \
+ return; \
+ }
+#endif
+// Unix part end
+
+
+/**
+ * Windows definitions
+ */
+#ifdef WINDOWS
+
+/* Force using Unicode throughout the code */
+#ifndef UNICODE
+#define UNICODE
+#endif
+
+/* Microsoft C Compiler does not support the C99 inline keyword */
+#ifndef __cplusplus
+#define inline __inline;
+#endif // _cplusplus
+
+/* Optimization macros supported by GCC but for which there is no
+ direct equivalent in the Microsoft C compiler */
+#define likely(_c) (_c)
+#define unlikely(_c) (_c)
+
+/* Disable certain warnings in the native CRC32 code. */
+#pragma warning(disable:4018) // Signed/unsigned mismatch.
+#pragma warning(disable:4244) // Possible loss of data in conversion.
+#pragma warning(disable:4267) // Possible loss of data.
+#pragma warning(disable:4996) // Use of deprecated function.
+
+#include
+#include
+#include
+
+#define snprintf(a, b ,c, d) _snprintf_s((a), (b), _TRUNCATE, (c), (d))
+
+/* A helper macro to dlsym the requisite dynamic symbol and bail-out on error. */
+#define LOAD_DYNAMIC_SYMBOL(func_type, func_ptr, env, handle, symbol) \
+ if ((func_ptr = (func_type) do_dlsym(env, handle, symbol)) == NULL) { \
+ return; \
+ }
+
+/**
+ * A helper function to dynamic load a 'symbol' from a given library-handle.
+ *
+ * @param env jni handle to report contingencies.
+ * @param handle handle to the dynamic library.
+ * @param symbol symbol to load.
+ * @return returns the address where the symbol is loaded in memory,
+ * NULL on error.
+ */
+static FARPROC WINAPI do_dlsym(JNIEnv *env, HMODULE handle, LPCSTR symbol) {
+ DWORD dwErrorCode = ERROR_SUCCESS;
+ FARPROC func_ptr = NULL;
+
+ if (!env || !handle || !symbol) {
+ THROW(env, "java/lang/InternalError", NULL);
+ return NULL;
+ }
+
+ func_ptr = GetProcAddress(handle, symbol);
+ if (func_ptr == NULL)
+ {
+ THROW(env, "java/lang/UnsatisfiedLinkError", symbol);
+ }
+ return func_ptr;
+}
+#endif
+// Windows part end
+
+
+#define LOCK_CLASS(env, clazz, classname) \
+ if ((*env)->MonitorEnter(env, clazz) != 0) { \
+ char exception_msg[128]; \
+ snprintf(exception_msg, 128, "Failed to lock %s", classname); \
+ THROW(env, "java/lang/InternalError", exception_msg); \
+ }
+
+#define UNLOCK_CLASS(env, clazz, classname) \
+ if ((*env)->MonitorExit(env, clazz) != 0) { \
+ char exception_msg[128]; \
+ snprintf(exception_msg, 128, "Failed to unlock %s", classname); \
+ THROW(env, "java/lang/InternalError", exception_msg); \
+ }
+
+#define RETRY_ON_EINTR(ret, expr) do { \
+ ret = expr; \
+} while ((ret == -1) && (errno == EINTR));
+
+#endif
+
+//vim: sw=2: ts=2: et
diff --git a/ratis-common/src/main/native/src/test/org/apache/ratis/util/test_bulk_crc32.c b/ratis-common/src/main/native/src/test/org/apache/ratis/util/test_bulk_crc32.c
new file mode 100644
index 0000000000..afd7262446
--- /dev/null
+++ b/ratis-common/src/main/native/src/test/org/apache/ratis/util/test_bulk_crc32.c
@@ -0,0 +1,113 @@
+/**
+ * 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.
+ */
+
+#include "org_apache_ratis.h"
+
+#include "bulk_crc32.h"
+
+#include
+#include
+#include
+#include
+
+#define EXPECT_ZERO(x) \
+ do { \
+ int __my_ret__ = x; \
+ if (__my_ret__) { \
+ fprintf(stderr, "TEST_ERROR: failed on line %d with return " \
+ "code %d: got nonzero from %s\n", __LINE__, __my_ret__, #x); \
+ return __my_ret__; \
+ } \
+ } while (0);
+
+static int testBulkVerifyCrc(int dataLen, int crcType, int bytesPerChecksum)
+{
+ int i;
+ uint8_t *data;
+ uint32_t *sums;
+ crc32_error_t errorData;
+
+ data = malloc(dataLen);
+ for (i = 0; i < dataLen; i++) {
+ data[i] = (i % 16) + 1;
+ }
+ sums = calloc(sizeof(uint32_t),
+ (dataLen + bytesPerChecksum - 1) / bytesPerChecksum);
+
+ EXPECT_ZERO(bulk_crc(data, dataLen, sums, crcType,
+ bytesPerChecksum, NULL));
+ EXPECT_ZERO(bulk_crc(data, dataLen, sums, crcType,
+ bytesPerChecksum, &errorData));
+ free(data);
+ free(sums);
+ return 0;
+}
+
+static int timeBulkCrc(int dataLen, int crcType, int bytesPerChecksum, int iterations)
+{
+ int i;
+ uint8_t *data;
+ uint32_t *sums;
+ crc32_error_t errorData;
+ clock_t start, fini;
+
+ data = malloc(dataLen);
+ for (i = 0; i < dataLen; i++) {
+ data[i] = (i % 16) + 1;
+ }
+ sums = calloc(sizeof(uint32_t),
+ (dataLen + bytesPerChecksum - 1) / bytesPerChecksum);
+
+ start = clock();
+ for (i = 0; i < iterations; i++) {
+ EXPECT_ZERO(bulk_crc(data, dataLen, sums, crcType,
+ bytesPerChecksum, NULL));
+ EXPECT_ZERO(bulk_crc(data, dataLen, sums, crcType,
+ bytesPerChecksum, &errorData));
+ }
+ fini = clock();
+ printf("CRC %d bytes @ %d bytes per checksum X %d iterations = %g\n",
+ dataLen, bytesPerChecksum, iterations, (double)(fini-start)/CLOCKS_PER_SEC);
+ free(data);
+ free(sums);
+ return 0;
+}
+
+int main(int argc, char **argv)
+{
+ /* Test running bulk_calculate_crc with some different algorithms and
+ * bytePerChecksum values. */
+ EXPECT_ZERO(testBulkVerifyCrc(4096, CRC32C_POLYNOMIAL, 512));
+ EXPECT_ZERO(testBulkVerifyCrc(4096, CRC32_ZLIB_POLYNOMIAL, 512));
+ EXPECT_ZERO(testBulkVerifyCrc(256, CRC32C_POLYNOMIAL, 1));
+ EXPECT_ZERO(testBulkVerifyCrc(256, CRC32_ZLIB_POLYNOMIAL, 1));
+ EXPECT_ZERO(testBulkVerifyCrc(1, CRC32C_POLYNOMIAL, 1));
+ EXPECT_ZERO(testBulkVerifyCrc(1, CRC32_ZLIB_POLYNOMIAL, 1));
+ EXPECT_ZERO(testBulkVerifyCrc(2, CRC32C_POLYNOMIAL, 1));
+ EXPECT_ZERO(testBulkVerifyCrc(17, CRC32C_POLYNOMIAL, 1));
+ EXPECT_ZERO(testBulkVerifyCrc(17, CRC32C_POLYNOMIAL, 2));
+ EXPECT_ZERO(testBulkVerifyCrc(17, CRC32_ZLIB_POLYNOMIAL, 2));
+ EXPECT_ZERO(testBulkVerifyCrc(17, CRC32C_POLYNOMIAL, 4));
+ EXPECT_ZERO(testBulkVerifyCrc(17, CRC32_ZLIB_POLYNOMIAL, 4));
+
+ EXPECT_ZERO(timeBulkCrc(16 * 1024, CRC32C_POLYNOMIAL, 512, 1000000));
+ EXPECT_ZERO(timeBulkCrc(16 * 1024, CRC32_ZLIB_POLYNOMIAL, 512, 1000000));
+
+ fprintf(stderr, "%s: SUCCESS.\n", argv[0]);
+ return EXIT_SUCCESS;
+}
diff --git a/ratis-common/src/test/java/org/apache/ratis/util/TestLifeCycle.java b/ratis-common/src/test/java/org/apache/ratis/util/TestLifeCycle.java
new file mode 100644
index 0000000000..82816c99c8
--- /dev/null
+++ b/ratis-common/src/test/java/org/apache/ratis/util/TestLifeCycle.java
@@ -0,0 +1,54 @@
+/**
+ * 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.ratis.util;
+
+import org.apache.ratis.util.LifeCycle;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.apache.ratis.util.LifeCycle.State.*;
+
+import java.util.*;
+
+public class TestLifeCycle {
+ /**
+ * Test if the successor map and the predecessor map are consistent.
+ * {@link LifeCycle} uses predecessors to validate transitions
+ * while this test uses successors.
+ */
+ @Test
+ public void testIsValid() throws Exception {
+ final Map> successors
+ = new EnumMap<>(LifeCycle.State.class);
+ put(NEW, successors, STARTING, CLOSED);
+ put(STARTING, successors, NEW, RUNNING, CLOSING, EXCEPTION);
+ put(RUNNING, successors, CLOSING, PAUSING, EXCEPTION);
+ put(PAUSING, successors, PAUSED, CLOSING, EXCEPTION);
+ put(PAUSED, successors, STARTING, CLOSING);
+ put(EXCEPTION, successors, CLOSING);
+ put(CLOSING , successors, CLOSED);
+ put(CLOSED, successors);
+
+ final List states = Arrays.asList(LifeCycle.State.values());
+ states.stream().forEach(
+ from -> states.forEach(
+ to -> Assert.assertEquals(from + " -> " + to,
+ successors.get(from).contains(to),
+ isValid(from, to))));
+ }
+}
diff --git a/ratis-examples/pom.xml b/ratis-examples/pom.xml
new file mode 100644
index 0000000000..53300999fa
--- /dev/null
+++ b/ratis-examples/pom.xml
@@ -0,0 +1,130 @@
+
+
+
+ 4.0.0
+
+ ratis-project-dist
+ org.apache.ratis
+ 1.0-SNAPSHOT
+ ../ratis-project-dist
+
+
+ ratis-examples
+ Ratis Examples
+
+
+
+ ratis-proto-shaded
+ org.apache.ratis
+ provided
+
+
+
+ ratis-common
+ org.apache.ratis
+ provided
+
+
+ ratis-common
+ org.apache.ratis
+ test
+ test-jar
+
+
+
+ ratis-client
+ org.apache.ratis
+ provided
+
+
+ ratis-client
+ org.apache.ratis
+ test
+ test-jar
+
+
+
+ ratis-server
+ org.apache.ratis
+ provided
+
+
+ ratis-server
+ org.apache.ratis
+ test
+ test-jar
+
+
+
+ ratis-hadoop
+ org.apache.ratis
+ provided
+
+
+ ratis-hadoop
+ org.apache.ratis
+ test
+ test-jar
+
+
+
+ ratis-grpc
+ org.apache.ratis
+ provided
+
+
+ ratis-grpc
+ org.apache.ratis
+ test
+ test-jar
+
+
+
+ ratis-netty
+ org.apache.ratis
+ provided
+
+
+ ratis-netty
+ org.apache.ratis
+ test
+ test-jar
+
+
+
+ org.slf4j
+ slf4j-api
+
+
+
+ com.google.guava
+ guava
+
+
+
+ junit
+ junit
+ test
+
+
+ org.mockito
+ mockito-all
+ test
+
+
+
+
diff --git a/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/ArithmeticStateMachine.java b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/ArithmeticStateMachine.java
new file mode 100644
index 0000000000..b241f3a621
--- /dev/null
+++ b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/ArithmeticStateMachine.java
@@ -0,0 +1,181 @@
+/**
+ * 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.ratis.examples.arithmetic;
+
+import com.google.common.base.Preconditions;
+
+import org.apache.ratis.conf.RaftProperties;
+import org.apache.ratis.examples.arithmetic.expression.Expression;
+import org.apache.ratis.protocol.Message;
+import org.apache.ratis.protocol.RaftClientReply;
+import org.apache.ratis.protocol.RaftClientRequest;
+import org.apache.ratis.server.impl.RaftServerConstants;
+import org.apache.ratis.server.protocol.TermIndex;
+import org.apache.ratis.server.storage.RaftStorage;
+import org.apache.ratis.shaded.proto.RaftProtos.LogEntryProto;
+import org.apache.ratis.statemachine.*;
+import org.apache.ratis.util.AutoCloseableLock;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+public class ArithmeticStateMachine extends BaseStateMachine {
+ static final Logger LOG = LoggerFactory.getLogger(ArithmeticStateMachine.class);
+
+ private final Map variables = new ConcurrentHashMap<>();
+
+ private final SimpleStateMachineStorage storage = new SimpleStateMachineStorage();
+ private final AtomicReference latestTermIndex = new AtomicReference<>();
+
+ private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
+
+ private AutoCloseableLock readLock() {
+ return AutoCloseableLock.acquire(lock.readLock());
+ }
+
+ private AutoCloseableLock writeLock() {
+ return AutoCloseableLock.acquire(lock.writeLock());
+ }
+
+ void reset() {
+ variables.clear();
+ latestTermIndex.set(null);
+ }
+
+ @Override
+ public void initialize(String id, RaftProperties properties, RaftStorage raftStorage)
+ throws IOException {
+ super.initialize(id, properties, raftStorage);
+ this.storage.init(raftStorage);
+ loadSnapshot(storage.getLatestSnapshot());
+ }
+
+ @Override
+ public void reinitialize(String id, RaftProperties properties, RaftStorage storage)
+ throws IOException {
+ close();
+ this.initialize(id, properties, storage);
+ }
+
+ @Override
+ public long takeSnapshot() throws IOException {
+ final Map copy;
+ final TermIndex last;
+ try(final AutoCloseableLock readLock = readLock()) {
+ copy = new HashMap<>(variables);
+ last = latestTermIndex.get();
+ }
+
+ File snapshotFile = new File(SimpleStateMachineStorage.getSnapshotFileName(
+ last.getTerm(), last.getIndex()));
+
+ try(final ObjectOutputStream out = new ObjectOutputStream(
+ new BufferedOutputStream(new FileOutputStream(snapshotFile)))) {
+ out.writeObject(copy);
+ } catch(IOException ioe) {
+ LOG.warn("Failed to write snapshot file \"" + snapshotFile
+ + "\", last applied index=" + last);
+ }
+
+ return last.getIndex();
+ }
+
+ public long loadSnapshot(SingleFileSnapshotInfo snapshot) throws IOException {
+ return load(snapshot, false);
+ }
+
+ private long load(SingleFileSnapshotInfo snapshot, boolean reload) throws IOException {
+ if (snapshot == null || !snapshot.getFile().getPath().toFile().exists()) {
+ LOG.warn("The snapshot file {} does not exist", snapshot);
+ return RaftServerConstants.INVALID_LOG_INDEX;
+ }
+
+ File snapshotFile =snapshot.getFile().getPath().toFile();
+ final TermIndex last = SimpleStateMachineStorage.getTermIndexFromSnapshotFile(snapshotFile);
+ try(final AutoCloseableLock writeLock = writeLock();
+ final ObjectInputStream in = new ObjectInputStream(
+ new BufferedInputStream(new FileInputStream(snapshotFile)))) {
+ if (reload) {
+ reset();
+ }
+ latestTermIndex.set(last);
+ variables.putAll((Map) in.readObject());
+ } catch (ClassNotFoundException e) {
+ throw new IllegalStateException(e);
+ }
+ return last.getIndex();
+ }
+
+ @Override
+ public StateMachineStorage getStateMachineStorage() {
+ return storage;
+ }
+
+ @Override
+ public CompletableFuture query(
+ RaftClientRequest request) {
+ final Expression q = Expression.Utils.bytes2Expression(
+ request.getMessage().getContent().toByteArray(), 0);
+ final Double result;
+ try(final AutoCloseableLock readLock = readLock()) {
+ result = q.evaluate(variables);
+ }
+ final Expression r = Expression.Utils.double2Expression(result);
+ LOG.debug("QUERY: {} = {}", q, r);
+ final RaftClientReply reply = new RaftClientReply(request,
+ Expression.Utils.toMessage(r));
+ return CompletableFuture.completedFuture(reply);
+ }
+
+ @Override
+ public void close() {
+ reset();
+ }
+
+ @Override
+ public CompletableFuture applyTransaction(TransactionContext trx) {
+ final LogEntryProto entry = trx.getLogEntry().get();
+ final AssignmentMessage assignment = new AssignmentMessage(
+ () -> entry.getSmLogEntry().getData());
+
+ final long index = entry.getIndex();
+ final Double result;
+ try(final AutoCloseableLock writeLock = writeLock()) {
+ result = assignment.evaluate(variables);
+ updateLatestTermIndex(entry.getTerm(), index);
+ }
+ final Expression r = Expression.Utils.double2Expression(result);
+ LOG.debug("{}: {} = {}, variables={}", index, assignment, r, variables);
+ return CompletableFuture.completedFuture(Expression.Utils.toMessage(r));
+ }
+
+ private void updateLatestTermIndex(long term, long index) {
+ final TermIndex newTI = TermIndex.newTermIndex(term, index);
+ final TermIndex oldTI = latestTermIndex.getAndSet(newTI);
+ if (oldTI != null) {
+ Preconditions.checkArgument(newTI.compareTo(oldTI) >= 0);
+ }
+ }
+}
diff --git a/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/AssignmentMessage.java b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/AssignmentMessage.java
new file mode 100644
index 0000000000..e4e7ca85bb
--- /dev/null
+++ b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/AssignmentMessage.java
@@ -0,0 +1,83 @@
+/**
+ * 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.ratis.examples.arithmetic;
+
+import static org.apache.ratis.util.ProtoUtils.toByteString;
+
+import java.nio.charset.Charset;
+import java.util.Map;
+
+import org.apache.ratis.examples.arithmetic.expression.Expression;
+import org.apache.ratis.examples.arithmetic.expression.Variable;
+import org.apache.ratis.protocol.Message;
+import org.apache.ratis.shaded.com.google.protobuf.ByteString;
+
+public class AssignmentMessage implements Message, Evaluable {
+ public static final Charset UTF8 = Charset.forName("UTF-8");
+
+ private final Variable variable;
+ private final Expression expression;
+
+ public AssignmentMessage(Variable variable, Expression expression) {
+ this.variable = variable;
+ this.expression = expression;
+ }
+
+ public AssignmentMessage(byte[] buf, int offset) {
+ variable = new Variable(buf, offset);
+ expression = Expression.Utils.bytes2Expression(buf, offset + variable.length());
+ }
+
+ public AssignmentMessage(Message message) {
+ this(message.getContent().toByteArray(), 0);
+ }
+
+ public Variable getVariable() {
+ return variable;
+ }
+
+ public Expression getExpression() {
+ return expression;
+ }
+
+ @Override
+ public ByteString getContent() {
+ final int length = variable.length() + expression.length();
+ final byte[] bytes = new byte[length];
+ final int offset = variable.toBytes(bytes, 0);
+ expression.toBytes(bytes, offset);
+ return toByteString(bytes);
+ }
+
+ @Override
+ public String toString() {
+ return variable + " = " + expression;
+ }
+
+ @Override
+ public Double evaluate(Map variableMap) {
+ final Double value = expression.evaluate(variableMap);
+ final String name = variable.getName();
+ if (value == null) {
+ variableMap.remove(name);
+ } else {
+ variableMap.put(name, value);
+ }
+ return value;
+ }
+}
diff --git a/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/Evaluable.java b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/Evaluable.java
new file mode 100644
index 0000000000..8afb080359
--- /dev/null
+++ b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/Evaluable.java
@@ -0,0 +1,24 @@
+/**
+ * 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.ratis.examples.arithmetic;
+
+import java.util.Map;
+
+public interface Evaluable {
+ Double evaluate(Map variableMap);
+}
diff --git a/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/BinaryExpression.java b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/BinaryExpression.java
new file mode 100644
index 0000000000..fceaef919f
--- /dev/null
+++ b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/BinaryExpression.java
@@ -0,0 +1,103 @@
+/**
+ * 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.ratis.examples.arithmetic.expression;
+
+import com.google.common.base.Preconditions;
+
+import java.util.Map;
+
+public class BinaryExpression implements Expression {
+ public enum Op {
+ ADD("+"), SUBTRACT("-"), MULT("*"), DIV("/");
+
+ final String symbol;
+
+ Op(String symbol) {
+ this.symbol = symbol;
+ }
+
+ byte byteValue() {
+ return (byte) ordinal();
+ }
+
+ @Override
+ public String toString() {
+ return symbol;
+ }
+
+ static final Op[] VALUES = Op.values();
+
+ static Op valueOf(byte b) {
+ Preconditions.checkArgument(b < VALUES.length);
+ return VALUES[b];
+ }
+ }
+
+ private final Op op;
+ private final Expression left, right;
+
+ BinaryExpression(byte[] buf, final int offset) {
+ Preconditions.checkArgument(buf[offset] == Type.BINARY.byteValue());
+ op = Op.valueOf(buf[offset + 1]);
+ left = Utils.bytes2Expression(buf, offset + 2);
+ right = Utils.bytes2Expression(buf, offset + 2 + left.length());
+ }
+
+ public BinaryExpression(Op op, Expression left, Expression right) {
+ this.op = op;
+ this.left = left;
+ this.right = right;
+ }
+
+ @Override
+ public int toBytes(byte[] buf, final int offset) {
+ buf[offset] = Type.BINARY.byteValue();
+ buf[offset + 1] = op.byteValue();
+ final int l = left.toBytes(buf, offset + 2);
+ final int r = right.toBytes(buf, offset + 2 + l);
+ return 2 + l + r;
+ }
+
+ @Override
+ public int length() {
+ return 2 + left.length() + right.length();
+ }
+
+ @Override
+ public Double evaluate(Map variableMap) {
+ final double l = left.evaluate(variableMap);
+ final double r = right.evaluate(variableMap);
+ switch (op) {
+ case ADD:
+ return l + r;
+ case SUBTRACT:
+ return l - r;
+ case MULT:
+ return l * r;
+ case DIV:
+ return l / r;
+ default:
+ throw new AssertionError("Unexpected op value: " + op);
+ }
+ }
+
+ @Override
+ public String toString() {
+ return "(" + left + " " + op + " " + right + ")";
+ }
+}
diff --git a/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/DoubleValue.java b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/DoubleValue.java
new file mode 100644
index 0000000000..7de3847fa3
--- /dev/null
+++ b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/DoubleValue.java
@@ -0,0 +1,61 @@
+/**
+ * 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.ratis.examples.arithmetic.expression;
+
+import com.google.common.base.Preconditions;
+
+import java.util.Map;
+
+public class DoubleValue implements Expression {
+ public static final DoubleValue ZERO = new DoubleValue(0);
+ public static final DoubleValue ONE = new DoubleValue(1);
+
+ private final double value;
+
+ public DoubleValue(double value) {
+ this.value = value;
+ }
+
+ DoubleValue(byte[] buf, int offset) {
+ this(Utils.bytes2double(buf, offset + 1));
+ Preconditions.checkArgument(buf[offset] == Type.DOUBLE.byteValue());
+ }
+
+ @Override
+ public int toBytes(byte[] buf, int offset) {
+ Preconditions.checkArgument(offset + length() <= buf.length);
+ buf[offset++] = Type.DOUBLE.byteValue();
+ Utils.double2bytes(value, buf, offset);
+ return length();
+ }
+
+ @Override
+ public int length() {
+ return 9;
+ }
+
+ @Override
+ public Double evaluate(Map variableMap) {
+ return value;
+ }
+
+ @Override
+ public String toString() {
+ return String.valueOf(value);
+ }
+}
diff --git a/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/Expression.java b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/Expression.java
new file mode 100644
index 0000000000..c90814a70f
--- /dev/null
+++ b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/Expression.java
@@ -0,0 +1,112 @@
+/*
+ * 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.ratis.examples.arithmetic.expression;
+
+import com.google.common.base.Preconditions;
+
+import static org.apache.ratis.util.ProtoUtils.toByteString;
+
+import org.apache.ratis.examples.arithmetic.Evaluable;
+import org.apache.ratis.protocol.Message;
+
+public interface Expression extends Evaluable {
+ enum Type {
+ NULL, VARIABLE, DOUBLE, BINARY, UNARY;
+
+ byte byteValue() {
+ return (byte) ordinal();
+ }
+
+ private static final Type[] VALUES = Type.values();
+
+ static Type valueOf(byte b) {
+ Preconditions.checkArgument(b >= 0);
+ Preconditions.checkArgument(b < VALUES.length);
+ return VALUES[b];
+ }
+ }
+
+ int toBytes(byte[] buf, int offset);
+
+ int length();
+
+ class Utils {
+ public static Message toMessage(final Expression e) {
+ return () -> {
+ final byte[] buf = new byte[e.length()];
+ final int length = e.toBytes(buf, 0);
+ Preconditions.checkState(length == buf.length);
+ return toByteString(buf);
+ };
+ }
+
+ public static Expression double2Expression(Double d) {
+ return d == null? NullValue.getInstance(): new DoubleValue(d);
+ }
+
+ public static Expression bytes2Expression(byte[] buf, int offset) {
+ final Type type = Type.valueOf(buf[offset]);
+ switch(type) {
+ case NULL: return NullValue.getInstance();
+ case DOUBLE: return new DoubleValue(buf, offset);
+ case VARIABLE: return new Variable(buf, offset);
+ case BINARY: return new BinaryExpression(buf, offset);
+ case UNARY: return new UnaryExpression(buf, offset);
+ default:
+ throw new AssertionError("Unknown expression type " + type);
+ }
+ }
+
+ public static int int2bytes(int v, byte[] buf, int offset) {
+ buf[offset ] = (byte) (v >>> 24);
+ buf[offset + 1] = (byte) (v >>> 16);
+ buf[offset + 2] = (byte) (v >>> 8);
+ buf[offset + 3] = (byte) (v);
+ return 4;
+ }
+
+ public static int long2bytes(long v, byte[] buf, int offset) {
+ int2bytes((int)(v >>> 32), buf, offset);
+ int2bytes((int) v , buf, offset + 4);
+ return 8;
+ }
+
+ public static int double2bytes(double d, byte[] buf, int offset) {
+ final long v = Double.doubleToRawLongBits(d);
+ return long2bytes(v, buf, offset);
+ }
+
+ public static int bytes2int(byte[] buf, int offset) {
+ return ((int) buf[offset] << 24)
+ + ((0xFF & buf[offset + 1]) << 16)
+ + ((0xFF & buf[offset + 2]) << 8)
+ + (0xFF & buf[offset + 3]);
+ }
+
+ public static long bytes2long(byte[] buf, int offset) {
+ return ((long)bytes2int(buf, offset) << 32)
+ + (0xFFFFFFFFL & bytes2int(buf, offset + 4));
+ }
+
+ public static double bytes2double(byte[] buf, int offset) {
+ final long v = bytes2long(buf, offset);
+ return Double.longBitsToDouble(v);
+ }
+ }
+}
+
diff --git a/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/NullValue.java b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/NullValue.java
new file mode 100644
index 0000000000..7f087d0d97
--- /dev/null
+++ b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/NullValue.java
@@ -0,0 +1,55 @@
+/**
+ * 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.ratis.examples.arithmetic.expression;
+
+import com.google.common.base.Preconditions;
+
+import java.util.Map;
+
+public class NullValue implements Expression {
+ private static final NullValue INSTANCE = new NullValue();
+
+ public static NullValue getInstance() {
+ return INSTANCE;
+ }
+
+ private NullValue() {
+ }
+
+ @Override
+ public int toBytes(byte[] buf, int offset) {
+ Preconditions.checkArgument(offset + length() <= buf.length);
+ buf[offset++] = Type.NULL.byteValue();
+ return length();
+ }
+
+ @Override
+ public int length() {
+ return 1;
+ }
+
+ @Override
+ public Double evaluate(Map variableMap) {
+ return null;
+ }
+
+ @Override
+ public String toString() {
+ return "null";
+ }
+}
diff --git a/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/UnaryExpression.java b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/UnaryExpression.java
new file mode 100644
index 0000000000..c340a1e775
--- /dev/null
+++ b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/UnaryExpression.java
@@ -0,0 +1,95 @@
+/**
+ * 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.ratis.examples.arithmetic.expression;
+
+import com.google.common.base.Preconditions;
+
+import java.util.Map;
+
+public class UnaryExpression implements Expression {
+ public enum Op {
+ NEG("~"), SQRT("√");
+
+ final String symbol;
+
+ Op(String symbol) {
+ this.symbol = symbol;
+ }
+
+ byte byteValue() {
+ return (byte) ordinal();
+ }
+
+ @Override
+ public String toString() {
+ return symbol;
+ }
+
+ static final Op[] VALUES = Op.values();
+
+ static Op valueOf(byte b) {
+ Preconditions.checkArgument(b < VALUES.length);
+ return VALUES[b];
+ }
+ }
+
+ final Op op;
+ final Expression expression;
+
+ UnaryExpression(byte[] buf, int offset) {
+ Preconditions.checkArgument(buf[offset] == Type.UNARY.byteValue());
+ op = Op.valueOf(buf[offset + 1]);
+ expression = Utils.bytes2Expression(buf, offset + 2);
+ }
+
+ public UnaryExpression(Op op, Expression expression) {
+ this.op = op;
+ this.expression = expression;
+ }
+
+ @Override
+ public int toBytes(byte[] buf, int offset) {
+ buf[offset] = Type.UNARY.byteValue();
+ buf[offset + 1] = op.byteValue();
+ final int length = expression.toBytes(buf, offset + 2);
+ return 2 + length;
+ }
+
+ @Override
+ public int length() {
+ return 2 + expression.length();
+ }
+
+ @Override
+ public Double evaluate(Map variableMap) {
+ final double value = expression.evaluate(variableMap);
+ switch (op) {
+ case NEG:
+ return -value;
+ case SQRT:
+ return Math.sqrt(value);
+ default:
+ throw new AssertionError("Unexpected op value: " + op);
+ }
+ }
+
+ @Override
+ public String toString() {
+ return op + " " + expression;
+ }
+}
diff --git a/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/Variable.java b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/Variable.java
new file mode 100644
index 0000000000..4e9a834260
--- /dev/null
+++ b/ratis-examples/src/main/java/org/apache/ratis/examples/arithmetic/expression/Variable.java
@@ -0,0 +1,126 @@
+/**
+ * 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.ratis.examples.arithmetic.expression;
+
+import com.google.common.base.Preconditions;
+
+import java.util.Map;
+import java.util.regex.Pattern;
+
+import org.apache.ratis.examples.arithmetic.AssignmentMessage;
+
+public class Variable implements Expression {
+ static final int LENGTH_LIMIT = 32;
+ static final String REGEX = "[a-zA-Z]\\w*";
+ static final Pattern PATTERN = Pattern.compile(REGEX);
+
+ static byte[] string2bytes(String s) {
+ final byte[] stringBytes = s.getBytes(AssignmentMessage.UTF8);
+ final byte[] bytes = new byte[stringBytes.length + 2];
+ bytes[0] = Type.VARIABLE.byteValue();
+ bytes[1] = (byte)stringBytes.length;
+ System.arraycopy(stringBytes, 0, bytes, 2, stringBytes.length);
+ return bytes;
+ }
+
+ static String extractString(byte[] buf, int offset) {
+ Preconditions.checkArgument(buf[offset] == Type.VARIABLE.byteValue());
+ final int length = buf[offset + 1];
+ final byte[] stringBytes = new byte[length];
+ System.arraycopy(buf, offset + 2, stringBytes, 0, length);
+ return new String(stringBytes, AssignmentMessage.UTF8);
+ }
+
+ static byte[] copyBytes(byte[] buf, int offset) {
+ Preconditions.checkArgument(buf[offset] == Type.VARIABLE.byteValue());
+ final int length = buf[offset + 1];
+ final byte[] copy = new byte[length + 2];
+ System.arraycopy(buf, offset, copy, 0, copy.length);
+ return copy;
+ }
+
+ private final String name;
+ private final byte[] encoded;
+
+ private Variable(String name, byte[] encoded) {
+ this.name = name;
+ this.encoded = encoded;
+
+ if (!PATTERN.matcher(name).matches()) {
+ throw new IllegalArgumentException("The variable name \"" + name
+ + "\" does not match the pattern \"" + PATTERN + "\"");
+ }
+ if (encoded.length - 2 > LENGTH_LIMIT) {
+ throw new IllegalArgumentException("The variable name \"" + name
+ + "\" is longer than the limit = " + LENGTH_LIMIT);
+ }
+ }
+
+ public Variable(byte[] buf, int offset) {
+ this(extractString(buf, offset), copyBytes(buf, offset));
+ }
+
+ public Variable(String name) {
+ this(name, string2bytes(name));
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ @Override
+ public int toBytes(byte[] buf, int offset) {
+ System.arraycopy(encoded, 0, buf, offset, encoded.length);
+ return encoded.length;
+ }
+
+ @Override
+ public int length() {
+ return encoded.length;
+ }
+
+ @Override
+ public Double evaluate(Map variableMap) {
+ final Double value = variableMap.get(name);
+ if (value == null) {
+ throw new IllegalStateException("Undefined variable \"" + name + "\"");
+ }
+ return value;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ } else if (obj == null || !(obj instanceof Variable)) {
+ return false;
+ }
+ final Variable that = (Variable)obj;
+ return this.getName().equals(that.getName());
+ }
+
+ @Override
+ public int hashCode() {
+ return name.hashCode();
+ }
+
+ @Override
+ public String toString() {
+ return name;
+ }
+}
diff --git a/ratis-examples/src/test/java/org/apache/ratis/TestBatchAppend.java b/ratis-examples/src/test/java/org/apache/ratis/TestBatchAppend.java
new file mode 100644
index 0000000000..15f65a9ca5
--- /dev/null
+++ b/ratis-examples/src/test/java/org/apache/ratis/TestBatchAppend.java
@@ -0,0 +1,172 @@
+/**
+ * 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.ratis;
+
+import org.apache.log4j.Level;
+import org.apache.ratis.MiniRaftCluster;
+import org.apache.ratis.RaftTestUtil;
+import org.apache.ratis.RaftTestUtil.SimpleMessage;
+import org.apache.ratis.client.RaftClient;
+import org.apache.ratis.conf.RaftProperties;
+import org.apache.ratis.examples.RaftExamplesTestUtil;
+import org.apache.ratis.server.impl.RaftServerImpl;
+import org.apache.ratis.server.simulation.RequestHandler;
+import org.apache.ratis.statemachine.SimpleStateMachine4Testing;
+import org.apache.ratis.statemachine.StateMachine;
+import org.apache.ratis.util.RaftUtils;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.Timeout;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.apache.ratis.server.RaftServerConfigKeys.*;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Enable raft.server.log.appender.batch.enabled and test LogAppender
+ */
+@RunWith(Parameterized.class)
+public class TestBatchAppend {
+ static Logger LOG = LoggerFactory.getLogger(TestBatchAppend.class);
+ static {
+ RaftUtils.setLogLevel(RaftServerImpl.LOG, Level.DEBUG);
+ RaftUtils.setLogLevel(RequestHandler.LOG, Level.DEBUG);
+ RaftUtils.setLogLevel(RaftClient.LOG, Level.DEBUG);
+ }
+
+ @Parameterized.Parameters
+ public static Collection data() throws IOException {
+ RaftProperties prop = new RaftProperties();
+ prop.setClass(MiniRaftCluster.STATEMACHINE_CLASS_KEY,
+ SimpleStateMachine4Testing.class, StateMachine.class);
+ prop.setInt(RAFT_LOG_SEGMENT_MAX_SIZE_KEY, 1024 * 8);
+ // enable batch appending
+ prop.setBoolean(RAFT_SERVER_LOG_APPENDER_BATCH_ENABLED_KEY, true);
+ // set batch appending buffer size to 4KB
+ prop.setInt(RAFT_SERVER_LOG_APPENDER_BUFFER_CAPACITY_KEY, 4 * 1024);
+
+ return RaftExamplesTestUtil.getMiniRaftClusters(prop, 3);
+ }
+
+ @Parameterized.Parameter
+ public MiniRaftCluster cluster;
+
+ @Rule
+ public Timeout globalTimeout = new Timeout(60 * 1000);
+
+ @After
+ public void tearDown() {
+ if (cluster != null) {
+ cluster.shutdown();
+ }
+ }
+
+ private class Sender extends Thread {
+ private final RaftClient client;
+ private final CountDownLatch latch;
+ private final SimpleMessage[] msgs;
+ private final AtomicBoolean succeed = new AtomicBoolean(false);
+
+ Sender(String clientId, String leaderId, CountDownLatch latch, int numMsg) {
+ this.latch = latch;
+ this.client = cluster.createClient(clientId, leaderId);
+ msgs = generateMsgs(numMsg);
+ }
+
+ SimpleMessage[] generateMsgs(int num) {
+ SimpleMessage[] msgs = new SimpleMessage[num * 6];
+ for (int i = 0; i < num; i++) {
+ for (int j = 0; j < 6; j++) {
+ byte[] bytes = new byte[1024 * (j + 1)];
+ Arrays.fill(bytes, (byte) j);
+ msgs[i * 6 + j] = new SimpleMessage(new String(bytes));
+ }
+ }
+ return msgs;
+ }
+
+ @Override
+ public void run() {
+ try {
+ latch.await();
+ } catch (InterruptedException ignored) {
+ LOG.warn("Client {} waiting for countdown latch got interrupted",
+ client.getId());
+ }
+ for (SimpleMessage msg : msgs) {
+ try {
+ client.send(msg);
+ } catch (IOException e) {
+ succeed.set(false);
+ LOG.warn("Client {} hit exception {}", client.getId(), e);
+ return;
+ }
+ }
+ succeed.set(true);
+ try {
+ client.close();
+ } catch (IOException ignore) {
+ }
+ }
+ }
+
+ @Test
+ public void testAppend() throws Exception {
+ final int numMsgs = 10;
+ final int numClients = 5;
+ cluster.start();
+ RaftTestUtil.waitForLeader(cluster);
+ final String leaderId = cluster.getLeader().getId();
+
+ // start several clients and write concurrently
+ CountDownLatch latch = new CountDownLatch(1);
+ final List senders = Stream.iterate(0, i -> i+1).limit(numClients)
+ .map(i -> new Sender("c" + i, leaderId, latch, numMsgs))
+ .collect(Collectors.toList());
+ senders.forEach(Thread::start);
+
+ latch.countDown();
+
+ senders.forEach(sender -> {
+ try {
+ sender.join();
+ } catch (InterruptedException ignored) {
+ }
+ });
+
+ for (Sender s : senders) {
+ Assert.assertTrue(s.succeed.get());
+ }
+
+ Assert.assertEquals(6 * numMsgs * numClients,
+ cluster.getLeader().getState().getLastAppliedIndex());
+ }
+}
diff --git a/ratis-examples/src/test/java/org/apache/ratis/TestRestartRaftPeer.java b/ratis-examples/src/test/java/org/apache/ratis/TestRestartRaftPeer.java
new file mode 100644
index 0000000000..37b4064d14
--- /dev/null
+++ b/ratis-examples/src/test/java/org/apache/ratis/TestRestartRaftPeer.java
@@ -0,0 +1,116 @@
+/**
+ * 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.ratis;
+
+import org.apache.log4j.Level;
+import org.apache.ratis.MiniRaftCluster;
+import org.apache.ratis.RaftTestUtil;
+import org.apache.ratis.RaftTestUtil.SimpleMessage;
+import org.apache.ratis.client.RaftClient;
+import org.apache.ratis.conf.RaftProperties;
+import org.apache.ratis.examples.RaftExamplesTestUtil;
+import org.apache.ratis.server.RaftServerConfigKeys;
+import org.apache.ratis.server.impl.RaftServerImpl;
+import org.apache.ratis.server.simulation.RequestHandler;
+import org.apache.ratis.server.storage.RaftLog;
+import org.apache.ratis.statemachine.SimpleStateMachine4Testing;
+import org.apache.ratis.statemachine.StateMachine;
+import org.apache.ratis.util.RaftUtils;
+import org.junit.Assert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.Timeout;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * Test restarting raft peers.
+ */
+@RunWith(Parameterized.class)
+public class TestRestartRaftPeer {
+ static Logger LOG = LoggerFactory.getLogger(TestRestartRaftPeer.class);
+ static {
+ RaftUtils.setLogLevel(RaftServerImpl.LOG, Level.DEBUG);
+ RaftUtils.setLogLevel(RaftLog.LOG, Level.DEBUG);
+ RaftUtils.setLogLevel(RequestHandler.LOG, Level.DEBUG);
+ RaftUtils.setLogLevel(RaftClient.LOG, Level.DEBUG);
+ }
+
+ @Parameterized.Parameters
+ public static Collection data() throws IOException {
+ RaftProperties prop = new RaftProperties();
+ prop.setClass(MiniRaftCluster.STATEMACHINE_CLASS_KEY,
+ SimpleStateMachine4Testing.class, StateMachine.class);
+ prop.setInt(RaftServerConfigKeys.RAFT_LOG_SEGMENT_MAX_SIZE_KEY, 1024 * 8);
+ return RaftExamplesTestUtil.getMiniRaftClusters(prop, 3);
+ }
+
+ @Parameterized.Parameter
+ public MiniRaftCluster cluster;
+
+ @Rule
+ public Timeout globalTimeout = new Timeout(60 * 1000);
+
+ @Test
+ public void restartFollower() throws Exception {
+ cluster.start();
+ RaftTestUtil.waitForLeader(cluster);
+ final String leaderId = cluster.getLeader().getId();
+ final RaftClient client = cluster.createClient("client", leaderId);
+
+ // write some messages
+ final byte[] content = new byte[1024];
+ Arrays.fill(content, (byte) 1);
+ final SimpleMessage message = new SimpleMessage(new String(content));
+ for (int i = 0; i < 10; i++) {
+ Assert.assertTrue(client.send(message).isSuccess());
+ }
+
+ // restart a follower
+ String followerId = cluster.getFollowers().get(0).getId();
+ LOG.info("Restart follower {}", followerId);
+ cluster.restartServer(followerId, false);
+
+ // write some more messages
+ for (int i = 0; i < 10; i++) {
+ Assert.assertTrue(client.send(message).isSuccess());
+ }
+ client.close();
+
+ // make sure the restarted follower can catchup
+ boolean catchup = false;
+ long lastAppliedIndex = 0;
+ for (int i = 0; i < 10 && !catchup; i++) {
+ Thread.sleep(500);
+ lastAppliedIndex = cluster.getServer(followerId).getState().getLastAppliedIndex();
+ catchup = lastAppliedIndex >= 20;
+ }
+ Assert.assertTrue("lastAppliedIndex=" + lastAppliedIndex, catchup);
+
+ // make sure the restarted peer's log segments is correct
+ cluster.restartServer(followerId, false);
+ Assert.assertTrue(cluster.getServer(followerId).getState().getLog()
+ .getLastEntry().getIndex() >= 20);
+ }
+}
diff --git a/ratis-examples/src/test/java/org/apache/ratis/examples/RaftExamplesTestUtil.java b/ratis-examples/src/test/java/org/apache/ratis/examples/RaftExamplesTestUtil.java
new file mode 100644
index 0000000000..873c0da314
--- /dev/null
+++ b/ratis-examples/src/test/java/org/apache/ratis/examples/RaftExamplesTestUtil.java
@@ -0,0 +1,90 @@
+/**
+ * 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.ratis.examples;
+
+import org.apache.ratis.MiniRaftCluster;
+import org.apache.ratis.conf.RaftProperties;
+import org.apache.ratis.grpc.MiniRaftClusterWithGRpc;
+import org.apache.ratis.hadooprpc.MiniRaftClusterWithHadoopRpc;
+import org.apache.ratis.netty.MiniRaftClusterWithNetty;
+import org.apache.ratis.server.simulation.MiniRaftClusterWithSimulatedRpc;
+import org.apache.ratis.statemachine.StateMachine;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class RaftExamplesTestUtil {
+ public static final Logger LOG = LoggerFactory.getLogger(RaftExamplesTestUtil.class);
+
+ private static void add(
+ Collection clusters, MiniRaftCluster.Factory factory,
+ String[] ids, RaftProperties properties)
+ throws IOException {
+ clusters.add(new Object[]{factory.newCluster(ids, properties, true)});
+ }
+
+ public static Collection getMiniRaftClusters(
+ RaftProperties prop, int clusterSize, Class... clusterClasses)
+ throws IOException {
+ final List> classes = Arrays.asList(clusterClasses);
+ final boolean isAll = classes.isEmpty(); //empty means all
+
+ final Iterator ids = new Iterator() {
+ private int i = 0;
+ @Override
+ public boolean hasNext() {
+ return true;
+ }
+ @Override
+ public String[] next() {
+ return MiniRaftCluster.generateIds(clusterSize, i++*clusterSize);
+ }
+ };
+
+ final List clusters = new ArrayList<>();
+
+ if (isAll || classes.contains(MiniRaftClusterWithSimulatedRpc.class)) {
+ add(clusters, MiniRaftClusterWithSimulatedRpc.FACTORY, ids.next(), prop);
+ }
+ if (isAll || classes.contains(MiniRaftClusterWithHadoopRpc.class)) {
+ add(clusters, MiniRaftClusterWithHadoopRpc.FACTORY, ids.next(), prop);
+ }
+ if (isAll || classes.contains(MiniRaftClusterWithNetty.class)) {
+ add(clusters, MiniRaftClusterWithNetty.FACTORY, ids.next(), prop);
+ }
+ if (isAll || classes.contains(MiniRaftClusterWithGRpc.class)) {
+ add(clusters, MiniRaftClusterWithGRpc.FACTORY, ids.next(), prop);
+ }
+ for(int i = 0; i < clusters.size(); i++) {
+ LOG.info(i + ": " + clusters.get(i)[0].getClass().getSimpleName());
+ }
+ LOG.info("#clusters = " + clusters.size());
+ return clusters;
+ }
+
+ public static Collection getMiniRaftClusters(
+ Class stateMachineClass, Class... clusterClasses) throws IOException {
+ final RaftProperties prop = new RaftProperties();
+ prop.setClass(MiniRaftCluster.STATEMACHINE_CLASS_KEY,
+ stateMachineClass, StateMachine.class);
+ return getMiniRaftClusters(prop, 3, clusterClasses);
+ }
+}
diff --git a/ratis-examples/src/test/java/org/apache/ratis/examples/arithmetic/TestArithmetic.java b/ratis-examples/src/test/java/org/apache/ratis/examples/arithmetic/TestArithmetic.java
new file mode 100644
index 0000000000..44cf8943d5
--- /dev/null
+++ b/ratis-examples/src/test/java/org/apache/ratis/examples/arithmetic/TestArithmetic.java
@@ -0,0 +1,106 @@
+/**
+ * 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.ratis.examples.arithmetic;
+
+
+import org.apache.log4j.Level;
+import org.apache.ratis.MiniRaftCluster;
+import org.apache.ratis.RaftTestUtil;
+import org.apache.ratis.client.RaftClient;
+import org.apache.ratis.examples.RaftExamplesTestUtil;
+import org.apache.ratis.examples.arithmetic.ArithmeticStateMachine;
+import org.apache.ratis.examples.arithmetic.AssignmentMessage;
+import org.apache.ratis.examples.arithmetic.expression.*;
+import org.apache.ratis.protocol.RaftClientReply;
+import org.apache.ratis.util.RaftUtils;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.io.IOException;
+import java.util.Collection;
+
+@RunWith(Parameterized.class)
+public class TestArithmetic {
+ static {
+ RaftUtils.setLogLevel(ArithmeticStateMachine.LOG, Level.ALL);
+ }
+
+ @Parameterized.Parameters
+ public static Collection data() throws IOException {
+ return RaftExamplesTestUtil.getMiniRaftClusters(ArithmeticStateMachine.class);
+ }
+
+ @Parameterized.Parameter
+ public MiniRaftCluster cluster;
+
+ @Test
+ public void testPythagorean() throws Exception {
+ cluster.start();
+ RaftTestUtil.waitForLeader(cluster);
+ final String leaderId = cluster.getLeader().getId();
+ final RaftClient client = cluster.createClient("pythagorean", leaderId);
+
+ final Variable a = new Variable("a");
+ final Variable b = new Variable("b");
+ final Variable c = new Variable("c");
+ final BinaryExpression a2 = new BinaryExpression(BinaryExpression.Op.MULT, a, a);
+ final BinaryExpression b2 = new BinaryExpression(BinaryExpression.Op.MULT, b, b);
+ final BinaryExpression c2 = new BinaryExpression(BinaryExpression.Op.ADD, a2, b2);
+ final AssignmentMessage pythagorean = new AssignmentMessage(c,
+ new UnaryExpression(UnaryExpression.Op.SQRT, c2));
+
+ final AssignmentMessage nullA = new AssignmentMessage(a, NullValue.getInstance());
+ final AssignmentMessage nullB = new AssignmentMessage(b, NullValue.getInstance());
+ final AssignmentMessage nullC = new AssignmentMessage(c, NullValue.getInstance());
+
+ for(int n = 3; n < 100; n += 2) {
+ int n2 = n*n;
+ int half_n2 = n2/2;
+
+ RaftClientReply r;
+ r = client.send(new AssignmentMessage(a, new DoubleValue(n)));
+ assertRaftClientReply(r, (double)n);
+ r = client.sendReadOnly(Expression.Utils.toMessage(a2));
+ assertRaftClientReply(r, (double)n2);
+ r = client.send(new AssignmentMessage(b, new DoubleValue(half_n2)));
+ assertRaftClientReply(r, (double)half_n2);
+ r = client.sendReadOnly(Expression.Utils.toMessage(b2));
+ assertRaftClientReply(r, (double)half_n2*half_n2);
+ r = client.send(pythagorean);
+ assertRaftClientReply(r, (double)half_n2 + 1);
+
+ r = client.send(nullA);
+ assertRaftClientReply(r, null);
+ r = client.send(nullB);
+ assertRaftClientReply(r, null);
+ r = client.send(nullC);
+ assertRaftClientReply(r, null);
+ }
+ client.close();
+ cluster.shutdown();
+ }
+
+ static void assertRaftClientReply(RaftClientReply reply, Double expected) {
+ Assert.assertTrue(reply.isSuccess());
+ final Expression e = Expression.Utils.bytes2Expression(
+ reply.getMessage().getContent().toByteArray(), 0);
+ Assert.assertEquals(expected, e.evaluate(null));
+ }
+}
diff --git a/ratis-examples/src/test/java/org/apache/ratis/examples/arithmetic/expression/TestExpression.java b/ratis-examples/src/test/java/org/apache/ratis/examples/arithmetic/expression/TestExpression.java
new file mode 100644
index 0000000000..a2d6e29784
--- /dev/null
+++ b/ratis-examples/src/test/java/org/apache/ratis/examples/arithmetic/expression/TestExpression.java
@@ -0,0 +1,107 @@
+/**
+ * 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.ratis.examples.arithmetic.expression;
+
+
+import org.apache.ratis.examples.arithmetic.expression.BinaryExpression;
+import org.apache.ratis.examples.arithmetic.expression.DoubleValue;
+import org.apache.ratis.examples.arithmetic.expression.Expression;
+import org.apache.ratis.examples.arithmetic.expression.UnaryExpression;
+import org.apache.ratis.examples.arithmetic.expression.Variable;
+import org.junit.Assert;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class TestExpression {
+ static final Logger LOG = LoggerFactory.getLogger(TestExpression.class);
+
+ @Test
+ public void testArithmeticUtils() throws Exception {
+ final Random ran = ThreadLocalRandom.current();
+ final byte[] buf = new byte[1024];
+ int offset = 0;
+
+ for(int i = 0; i < 10; i++) {
+ {
+ final int n = ran.nextInt();
+ Expression.Utils.int2bytes(n, buf, offset);
+ final int m = Expression.Utils.bytes2int(buf, offset);
+ Assert.assertEquals(n, m);
+ offset += 4;
+ }
+ {
+ final long n = ran.nextLong();
+ Expression.Utils.long2bytes(n, buf, offset);
+ final long m = Expression.Utils.bytes2long(buf, offset);
+ Assert.assertEquals(n, m);
+ offset += 8;
+ }
+ {
+ final double n = ran.nextDouble();
+ Expression.Utils.double2bytes(n, buf, offset);
+ final double m = Expression.Utils.bytes2double(buf, offset);
+ Assert.assertTrue(n == m);
+ offset += 8;
+ }
+ }
+ }
+ @Test
+ public void testOp() throws Exception {
+ for(BinaryExpression.Op op : BinaryExpression.Op.values()) {
+ final byte b = op.byteValue();
+ Assert.assertEquals(op, BinaryExpression.Op.valueOf(b));
+ }
+ for(UnaryExpression.Op op : UnaryExpression.Op.values()) {
+ final byte b = op.byteValue();
+ Assert.assertEquals(op, UnaryExpression.Op.valueOf(b));
+ }
+ }
+
+ @Test
+ public void testExpression() throws Exception {
+ final byte[] buf = new byte[1024];
+ int offset = 0;
+
+ {
+ final Variable a = new Variable("pi");
+ LOG.info("var a: " + a);
+ final int len = a.toBytes(buf, offset);
+ final Variable a2 = new Variable(buf, offset);
+ LOG.info("var a2: " + a2);
+ Assert.assertEquals(a.getName(), a2.getName());
+ Assert.assertEquals(len, a.length());
+ Assert.assertEquals(len, a2.length());
+ offset += len;
+ }
+
+ {
+ final DoubleValue three = new DoubleValue(3);
+ LOG.info("double three: " + three.evaluate(null));
+ final int len = three.toBytes(buf, offset);
+ final DoubleValue three2 = new DoubleValue(buf, offset);
+ LOG.info("double three2: " + three2.evaluate(null));
+ Assert.assertTrue(three.evaluate(null).equals(three2.evaluate(null)));
+ Assert.assertEquals(len, three.length());
+ Assert.assertEquals(len, three2.length());
+ }
+ }
+}
diff --git a/ratis-examples/src/test/java/org/apache/ratis/statemachine/TestRaftStateMachineException.java b/ratis-examples/src/test/java/org/apache/ratis/statemachine/TestRaftStateMachineException.java
new file mode 100644
index 0000000000..1f885ea954
--- /dev/null
+++ b/ratis-examples/src/test/java/org/apache/ratis/statemachine/TestRaftStateMachineException.java
@@ -0,0 +1,88 @@
+/**
+ * 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.ratis.statemachine;
+
+import org.apache.log4j.Level;
+import org.apache.ratis.MiniRaftCluster;
+import org.apache.ratis.RaftTestUtil;
+import org.apache.ratis.client.RaftClient;
+import org.apache.ratis.examples.RaftExamplesTestUtil;
+import org.apache.ratis.protocol.Message;
+import org.apache.ratis.protocol.StateMachineException;
+import org.apache.ratis.server.impl.RaftServerImpl;
+import org.apache.ratis.server.simulation.RequestHandler;
+import org.apache.ratis.server.storage.RaftLog;
+import org.apache.ratis.statemachine.SimpleStateMachine4Testing;
+import org.apache.ratis.statemachine.TransactionContext;
+import org.apache.ratis.util.RaftUtils;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.concurrent.CompletableFuture;
+
+import static org.junit.Assert.fail;
+
+@RunWith(Parameterized.class)
+public class TestRaftStateMachineException {
+ static {
+ RaftUtils.setLogLevel(RaftServerImpl.LOG, Level.DEBUG);
+ RaftUtils.setLogLevel(RaftLog.LOG, Level.DEBUG);
+ RaftUtils.setLogLevel(RequestHandler.LOG, Level.DEBUG);
+ RaftUtils.setLogLevel(RaftClient.LOG, Level.DEBUG);
+ }
+
+ protected static class StateMachineWithException extends SimpleStateMachine4Testing {
+ @Override
+ public CompletableFuture applyTransaction(TransactionContext trx) {
+ CompletableFuture future = new CompletableFuture<>();
+ future.completeExceptionally(new StateMachineException("Fake Exception"));
+ return future;
+ }
+ }
+
+ @Parameterized.Parameters
+ public static Collection data() throws IOException {
+ return RaftExamplesTestUtil.getMiniRaftClusters(
+ StateMachineWithException.class);
+ }
+
+ @Parameterized.Parameter
+ public MiniRaftCluster cluster;
+
+ @Test
+ public void testHandleStateMachineException() throws Exception {
+ cluster.start();
+ RaftTestUtil.waitForLeader(cluster);
+
+ final String leaderId = cluster.getLeader().getId();
+
+ try(final RaftClient client = cluster.createClient("client", leaderId)) {
+ client.send(new RaftTestUtil.SimpleMessage("m"));
+ fail("Exception expected");
+ } catch (StateMachineException e) {
+ e.printStackTrace();
+ Assert.assertTrue(e.getMessage().contains("Fake Exception"));
+ }
+
+ cluster.shutdown();
+ }
+}
diff --git a/ratis-examples/src/test/resources/log4j.properties b/ratis-examples/src/test/resources/log4j.properties
new file mode 100644
index 0000000000..ced0687caa
--- /dev/null
+++ b/ratis-examples/src/test/resources/log4j.properties
@@ -0,0 +1,18 @@
+# Licensed 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.
+# log4j configuration used during build and unit tests
+
+log4j.rootLogger=info,stdout
+log4j.threshold=ALL
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%d{ISO8601} %-5p %c{2} (%F:%M(%L)) - %m%n
diff --git a/ratis-grpc/pom.xml b/ratis-grpc/pom.xml
new file mode 100644
index 0000000000..6a46be55b8
--- /dev/null
+++ b/ratis-grpc/pom.xml
@@ -0,0 +1,93 @@
+
+
+
+ 4.0.0
+
+ ratis-project-dist
+ org.apache.ratis
+ 1.0-SNAPSHOT
+ ../ratis-project-dist
+
+
+ ratis-grpc
+ Ratis gRPC Support
+
+
+
+ ratis-proto-shaded
+ org.apache.ratis
+ provided
+
+
+
+ ratis-common
+ org.apache.ratis
+ provided
+
+
+ ratis-common
+ org.apache.ratis
+ test
+ test-jar
+
+
+
+ ratis-client
+ org.apache.ratis
+ provided
+
+
+ ratis-client
+ org.apache.ratis
+ test
+ test-jar
+
+
+
+ ratis-server
+ org.apache.ratis
+ provided
+
+
+ ratis-server
+ org.apache.ratis
+ test
+ test-jar
+
+
+
+ org.slf4j
+ slf4j-api
+
+
+
+ com.google.guava
+ guava
+
+
+
+ junit
+ junit
+ test
+
+
+ org.mockito
+ mockito-all
+ test
+
+
+
diff --git a/ratis-grpc/src/main/java/org/apache/ratis/grpc/RaftGRpcService.java b/ratis-grpc/src/main/java/org/apache/ratis/grpc/RaftGRpcService.java
new file mode 100644
index 0000000000..9ea23c3b0e
--- /dev/null
+++ b/ratis-grpc/src/main/java/org/apache/ratis/grpc/RaftGRpcService.java
@@ -0,0 +1,185 @@
+/**
+ * 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.ratis.grpc;
+
+import com.google.common.base.Preconditions;
+import org.apache.ratis.conf.RaftProperties;
+import org.apache.ratis.grpc.client.RaftClientProtocolService;
+import org.apache.ratis.grpc.server.RaftServerProtocolClient;
+import org.apache.ratis.grpc.server.RaftServerProtocolService;
+import org.apache.ratis.protocol.RaftPeer;
+import org.apache.ratis.server.RaftServer;
+import org.apache.ratis.server.RaftServerRpc;
+import org.apache.ratis.shaded.io.grpc.Server;
+import org.apache.ratis.shaded.io.grpc.ServerBuilder;
+import org.apache.ratis.shaded.io.grpc.netty.NettyServerBuilder;
+import org.apache.ratis.shaded.proto.RaftProtos.*;
+import org.apache.ratis.util.CodeInjectionForTesting;
+import org.apache.ratis.util.ExitUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.apache.ratis.grpc.RaftGrpcConfigKeys.*;
+
+/** A grpc implementation of {@link RaftServerRpc}. */
+public class RaftGRpcService implements RaftServerRpc {
+ static final Logger LOG = LoggerFactory.getLogger(RaftGRpcService.class);
+ public static final String GRPC_SEND_SERVER_REQUEST =
+ RaftGRpcService.class.getSimpleName() + ".sendRequest";
+
+ public static class Builder extends RaftServerRpc.Builder {
+ private int maxMessageSize = RAFT_GRPC_MESSAGE_MAXSIZE_DEFAULT;
+
+ private Builder() {
+ super(RAFT_GRPC_SERVER_PORT_DEFAULT);
+ }
+
+ public int getMaxMessageSize() {
+ return maxMessageSize;
+ }
+
+ public Builder setMaxMessageSize(int maxMessageSize) {
+ this.maxMessageSize = maxMessageSize;
+ return this;
+ }
+
+ public Builder setFromRaftProperties(RaftProperties properties) {
+ setPort(properties.getInt(RAFT_GRPC_SERVER_PORT_KEY,
+ RAFT_GRPC_SERVER_PORT_DEFAULT));
+ setMaxMessageSize(properties.getInt(RAFT_GRPC_MESSAGE_MAXSIZE_KEY,
+ RAFT_GRPC_MESSAGE_MAXSIZE_DEFAULT));
+ return this;
+ }
+
+ @Override
+ public Builder getThis() {
+ return this;
+ }
+
+ @Override
+ public RaftGRpcService build() {
+ return new RaftGRpcService(getServer(), getPort(), getMaxMessageSize());
+ }
+ }
+
+ public static Builder newBuilder() {
+ return new Builder();
+ }
+
+ private final Server server;
+ private final InetSocketAddress address;
+ private final Map peers =
+ Collections.synchronizedMap(new HashMap<>());
+ private final String selfId;
+
+ private RaftGRpcService(RaftServer raftServer, int port, int maxMessageSize) {
+ ServerBuilder serverBuilder = ServerBuilder.forPort(port);
+ selfId = raftServer.getId();
+ server = ((NettyServerBuilder) serverBuilder).maxMessageSize(maxMessageSize)
+ .addService(new RaftServerProtocolService(selfId, raftServer))
+ .addService(new RaftClientProtocolService(selfId, raftServer))
+ .build();
+
+ // start service to determine the port (in case port is configured as 0)
+ startService();
+ address = new InetSocketAddress(server.getPort());
+ LOG.info("Server started, listening on " + address.getPort());
+ }
+
+ @Override
+ public void start() {
+ // do nothing
+ }
+
+ private void startService() {
+ try {
+ server.start();
+ } catch (IOException e) {
+ ExitUtils.terminate(1, "Failed to start Grpc server", e, LOG);
+ }
+ Runtime.getRuntime().addShutdownHook(new Thread() {
+ @Override
+ public void run() {
+ System.err.println("*** shutting down gRPC server since JVM is shutting down");
+ RaftGRpcService.this.close();
+ System.err.println("*** server shut down");
+ }
+ });
+ }
+
+ @Override
+ public void close() {
+ if (server != null) {
+ server.shutdown();
+ }
+ shutdownClients();
+ }
+
+ @Override
+ public InetSocketAddress getInetSocketAddress() {
+ return address;
+ }
+
+ @Override
+ public AppendEntriesReplyProto appendEntries(
+ AppendEntriesRequestProto request) throws IOException {
+ throw new UnsupportedOperationException(
+ "Blocking AppendEntries call is not supported");
+ }
+
+ @Override
+ public InstallSnapshotReplyProto installSnapshot(
+ InstallSnapshotRequestProto request) throws IOException {
+ throw new UnsupportedOperationException(
+ "Blocking InstallSnapshot call is not supported");
+ }
+
+ @Override
+ public RequestVoteReplyProto requestVote(RequestVoteRequestProto request)
+ throws IOException {
+ CodeInjectionForTesting.execute(GRPC_SEND_SERVER_REQUEST, selfId,
+ null, request);
+
+ RaftServerProtocolClient target = Preconditions.checkNotNull(
+ peers.get(request.getServerRequest().getReplyId()));
+ return target.requestVote(request);
+ }
+
+ @Override
+ public void addPeers(Iterable newPeers) {
+ for (RaftPeer p : newPeers) {
+ if (!peers.containsKey(p.getId())) {
+ peers.put(p.getId(), new RaftServerProtocolClient(p));
+ }
+ }
+ }
+
+ private void shutdownClients() {
+ peers.values().forEach(RaftServerProtocolClient::shutdown);
+ }
+
+ public RaftServerProtocolClient getRpcClient(RaftPeer peer) {
+ return peers.get(peer.getId());
+ }
+}
diff --git a/ratis-grpc/src/main/java/org/apache/ratis/grpc/RaftGrpcConfigKeys.java b/ratis-grpc/src/main/java/org/apache/ratis/grpc/RaftGrpcConfigKeys.java
new file mode 100644
index 0000000000..ffec8ff105
--- /dev/null
+++ b/ratis-grpc/src/main/java/org/apache/ratis/grpc/RaftGrpcConfigKeys.java
@@ -0,0 +1,47 @@
+/**
+ * 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.ratis.grpc;
+
+import org.apache.ratis.client.RaftClientConfigKeys;
+
+public interface RaftGrpcConfigKeys {
+ String PREFIX = "raft.grpc";
+
+ String RAFT_GRPC_SERVER_PORT_KEY = PREFIX + ".server.port";
+ int RAFT_GRPC_SERVER_PORT_DEFAULT = 0;
+
+ String RAFT_GRPC_MESSAGE_MAXSIZE_KEY = PREFIX + ".message.maxsize";
+ int RAFT_GRPC_MESSAGE_MAXSIZE_DEFAULT = 64 * 1024 * 1024; // 64 MB
+
+ String RAFT_GRPC_LEADER_MAX_OUTSTANDING_APPENDS_KEY =
+ PREFIX + "leader.max.outstanding.appends";
+ int RAFT_GRPC_LEADER_MAX_OUTSTANDING_APPENDS_DEFAULT = 128;
+
+ String RAFT_GRPC_CLIENT_MAX_OUTSTANDING_APPENDS_KEY =
+ PREFIX + "client.max.outstanding.appends";
+ int RAFT_GRPC_CLIENT_MAX_OUTSTANDING_APPENDS_DEFAULT = 128;
+
+ String RAFT_OUTPUTSTREAM_BUFFER_SIZE_KEY = "raft.outputstream.buffer.size";
+ int RAFT_OUTPUTSTREAM_BUFFER_SIZE_DEFAULT = 64 * 1024;
+
+ String RAFT_OUTPUTSTREAM_MAX_RETRY_TIMES_KEY = "raft.outputstream.max.retry.times";
+ int RAFT_OUTPUTSTREAM_MAX_RETRY_TIMES_DEFAULT = 5;
+
+ String RAFT_OUTPUTSTREAM_RETRY_INTERVAL_KEY = "raft.outputstream.retry.interval";
+ long RAFT_OUTPUTSTREAM_RETRY_INTERVAL_DEFAULT = RaftClientConfigKeys.RAFT_RPC_TIMEOUT_MS_DEFAULT;
+}
diff --git a/ratis-grpc/src/main/java/org/apache/ratis/grpc/RaftGrpcUtil.java b/ratis-grpc/src/main/java/org/apache/ratis/grpc/RaftGrpcUtil.java
new file mode 100644
index 0000000000..52ed851bf1
--- /dev/null
+++ b/ratis-grpc/src/main/java/org/apache/ratis/grpc/RaftGrpcUtil.java
@@ -0,0 +1,87 @@
+/**
+ * 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.ratis.grpc;
+
+import org.apache.ratis.shaded.io.grpc.Metadata;
+import org.apache.ratis.shaded.io.grpc.Status;
+import org.apache.ratis.shaded.io.grpc.StatusRuntimeException;
+import org.apache.ratis.util.RaftUtils;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.lang.reflect.Constructor;
+
+public class RaftGrpcUtil {
+ public static final Metadata.Key EXCEPTION_TYPE_KEY =
+ Metadata.Key.of("exception-type", Metadata.ASCII_STRING_MARSHALLER);
+
+ public static String stringifyException(Throwable e) {
+ StringWriter stm = new StringWriter();
+ PrintWriter wrt = new PrintWriter(stm);
+ e.printStackTrace(wrt);
+ wrt.close();
+ return stm.toString();
+ }
+
+ public static StatusRuntimeException wrapException(Throwable t) {
+ Metadata trailers = new Metadata();
+ trailers.put(EXCEPTION_TYPE_KEY, t.getClass().getCanonicalName());
+ return new StatusRuntimeException(
+ Status.INTERNAL.withDescription(RaftGrpcUtil.stringifyException(t)),
+ trailers);
+ }
+
+ public static IOException unwrapException(StatusRuntimeException se) {
+ final Metadata trailers = se.getTrailers();
+ final Status status = se.getStatus();
+ if (trailers != null && status != null) {
+ final String className = trailers.get(EXCEPTION_TYPE_KEY);
+ if (className != null) {
+ try {
+ Class clazz = Class.forName(className);
+ final Exception unwrapped = instantiateException(
+ clazz.asSubclass(Exception.class), status.getDescription(), se);
+ return RaftUtils.asIOException(unwrapped);
+ } catch (Exception e) {
+ return new IOException(se);
+ }
+ }
+ }
+ return new IOException(se);
+ }
+
+ public static IOException unwrapIOException(Throwable t) {
+ final IOException e;
+ if (t instanceof StatusRuntimeException) {
+ e = RaftGrpcUtil.unwrapException((StatusRuntimeException) t);
+ } else {
+ e = RaftUtils.asIOException(t);
+ }
+ return e;
+ }
+
+ private static Exception instantiateException(Class cls,
+ String message, Exception from) throws Exception {
+ Constructor cn = cls.getConstructor(String.class);
+ cn.setAccessible(true);
+ Exception ex = cn.newInstance(message);
+ ex.initCause(from);
+ return ex;
+ }
+}
diff --git a/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/AppendStreamer.java b/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/AppendStreamer.java
new file mode 100644
index 0000000000..cb05b33b10
--- /dev/null
+++ b/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/AppendStreamer.java
@@ -0,0 +1,396 @@
+/**
+ * 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.ratis.grpc.client;
+
+import com.google.common.base.Preconditions;
+
+import org.apache.ratis.shaded.com.google.protobuf.ByteString;
+import org.apache.ratis.shaded.proto.RaftProtos.RaftClientReplyProto;
+import org.apache.ratis.shaded.proto.RaftProtos.RaftClientRequestProto;
+import org.apache.ratis.shaded.proto.RaftProtos.RaftRpcRequestProto;
+import org.apache.ratis.conf.RaftProperties;
+import org.apache.ratis.grpc.RaftGrpcConfigKeys;
+import org.apache.ratis.grpc.RaftGrpcUtil;
+import org.apache.ratis.protocol.NotLeaderException;
+import org.apache.ratis.protocol.RaftClientReply;
+import org.apache.ratis.protocol.RaftPeer;
+import org.apache.ratis.util.Daemon;
+import org.apache.ratis.util.PeerProxyMap;
+import org.apache.ratis.util.RaftUtils;
+import org.apache.ratis.util.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.*;
+import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static org.apache.ratis.client.impl.ClientProtoUtils.*;
+import static org.apache.ratis.grpc.RaftGrpcConfigKeys.RAFT_GRPC_CLIENT_MAX_OUTSTANDING_APPENDS_DEFAULT;
+import static org.apache.ratis.grpc.RaftGrpcConfigKeys.RAFT_GRPC_CLIENT_MAX_OUTSTANDING_APPENDS_KEY;
+
+public class AppendStreamer implements Closeable {
+ public static final Logger LOG = LoggerFactory.getLogger(AppendStreamer.class);
+
+ enum RunningState {RUNNING, LOOK_FOR_LEADER, CLOSED, ERROR}
+
+ private static class ExceptionAndRetry {
+ private final Map exceptionMap = new HashMap<>();
+ private final AtomicInteger retryTimes = new AtomicInteger(0);
+ private final int maxRetryTimes;
+ private final long retryInterval;
+
+ ExceptionAndRetry(RaftProperties prop) {
+ maxRetryTimes = prop.getInt(
+ RaftGrpcConfigKeys.RAFT_OUTPUTSTREAM_MAX_RETRY_TIMES_KEY,
+ RaftGrpcConfigKeys.RAFT_OUTPUTSTREAM_MAX_RETRY_TIMES_DEFAULT);
+ retryInterval = prop.getTimeDuration(
+ RaftGrpcConfigKeys.RAFT_OUTPUTSTREAM_RETRY_INTERVAL_KEY,
+ RaftGrpcConfigKeys.RAFT_OUTPUTSTREAM_RETRY_INTERVAL_DEFAULT,
+ TimeUnit.MILLISECONDS);
+ }
+
+ void addException(String peer, IOException e) {
+ exceptionMap.put(peer, e);
+ retryTimes.incrementAndGet();
+ }
+
+ IOException getCombinedException() {
+ return new IOException("Exceptions: " + exceptionMap);
+ }
+
+ boolean shouldRetry() {
+ return retryTimes.get() <= maxRetryTimes;
+ }
+ }
+
+ private final Deque dataQueue;
+ private final Deque ackQueue;
+ private final int maxPendingNum;
+
+ private final PeerProxyMap proxyMap;
+ private final Map peers;
+ private String leaderId;
+ private volatile RaftClientProtocolProxy leaderProxy;
+ private final String clientId;
+
+ private volatile RunningState running = RunningState.RUNNING;
+ private final ExceptionAndRetry exceptionAndRetry;
+ private final Sender senderThread;
+
+ AppendStreamer(RaftProperties prop, Collection peers,
+ String leaderId, String clientId) {
+ this.clientId = clientId;
+ maxPendingNum = prop.getInt(
+ RAFT_GRPC_CLIENT_MAX_OUTSTANDING_APPENDS_KEY,
+ RAFT_GRPC_CLIENT_MAX_OUTSTANDING_APPENDS_DEFAULT);
+ dataQueue = new ConcurrentLinkedDeque<>();
+ ackQueue = new ConcurrentLinkedDeque<>();
+ exceptionAndRetry = new ExceptionAndRetry(prop);
+
+ this.peers = peers.stream().collect(
+ Collectors.toMap(RaftPeer::getId, Function.identity()));
+ proxyMap = new PeerProxyMap<>(
+ raftPeer -> new RaftClientProtocolProxy(raftPeer, ResponseHandler::new));
+ proxyMap.addPeers(peers);
+ refreshLeaderProxy(leaderId, null);
+
+ senderThread = new Sender();
+ senderThread.setName(this.toString() + "-sender");
+ senderThread.start();
+ }
+
+ private synchronized void refreshLeaderProxy(String suggested,
+ String oldLeader) {
+ if (suggested != null) {
+ leaderId = suggested;
+ } else {
+ if (oldLeader == null) {
+ leaderId = peers.keySet().iterator().next();
+ } else {
+ leaderId = StringUtils.next(oldLeader, peers.keySet());
+ }
+ }
+ LOG.debug("{} switches leader from {} to {}. suggested leader: {}", this,
+ oldLeader, leaderId, suggested);
+ if (leaderProxy != null) {
+ leaderProxy.closeCurrentSession();
+ }
+ try {
+ leaderProxy = proxyMap.getProxy(leaderId);
+ } catch (IOException e) {
+ LOG.error("Should not hit IOException here", e);
+ refreshLeader(null, leaderId);
+ }
+ }
+
+ private boolean isRunning() {
+ return running == RunningState.RUNNING ||
+ running == RunningState.LOOK_FOR_LEADER;
+ }
+
+ private void checkState() throws IOException {
+ if (!isRunning()) {
+ throwException("The AppendStreamer has been closed");
+ }
+ }
+
+ synchronized void write(ByteString content, long seqNum)
+ throws IOException {
+ checkState();
+ while (isRunning() && dataQueue.size() >= maxPendingNum) {
+ try {
+ wait();
+ } catch (InterruptedException ignored) {
+ }
+ }
+ if (isRunning()) {
+ // wrap the current buffer into a RaftClientRequestProto
+ final RaftClientRequestProto request = genRaftClientRequestProto(
+ clientId, leaderId, seqNum, content, false);
+ dataQueue.offer(request);
+ this.notifyAll();
+ } else {
+ throwException(this + " got closed.");
+ }
+ }
+
+ synchronized void flush() throws IOException {
+ checkState();
+ if (dataQueue.isEmpty() && ackQueue.isEmpty()) {
+ return;
+ }
+ // wait for the pending Q to become empty
+ while (isRunning() && (!dataQueue.isEmpty() || !ackQueue.isEmpty())) {
+ try {
+ wait();
+ } catch (InterruptedException ignored) {
+ }
+ }
+ if (!isRunning() && (!dataQueue.isEmpty() || !ackQueue.isEmpty())) {
+ throwException(this + " got closed before finishing flush");
+ }
+ }
+
+ @Override
+ public void close() throws IOException {
+ if (!isRunning()) {
+ return;
+ }
+ flush();
+
+ running = RunningState.CLOSED;
+ senderThread.interrupt();
+ try {
+ senderThread.join();
+ } catch (InterruptedException ignored) {
+ }
+ proxyMap.close();
+ }
+
+ @Override
+ public String toString() {
+ return this.getClass().getSimpleName() + "-" + clientId;
+ }
+
+ private class Sender extends Daemon {
+ @Override
+ public void run() {
+ while (isRunning()) {
+
+ synchronized (AppendStreamer.this) {
+ while (isRunning() && shouldWait()) {
+ try {
+ AppendStreamer.this.wait();
+ } catch (InterruptedException ignored) {
+ }
+ }
+ if (running == RunningState.RUNNING) {
+ RaftClientRequestProto next = dataQueue.poll();
+ leaderProxy.onNext(next);
+ ackQueue.offer(next);
+ }
+ }
+ }
+ }
+
+ private boolean shouldWait() {
+ // the sender should wait if any of the following is true
+ // 1) there is no data to send
+ // 2) there are too many outstanding pending requests
+ // 3) Error/NotLeaderException just happened, we're still waiting for
+ // the first response to confirm the new leader
+ return dataQueue.isEmpty() || ackQueue.size() >= maxPendingNum ||
+ running == RunningState.LOOK_FOR_LEADER;
+ }
+ }
+
+ /** the response handler for stream RPC */
+ private class ResponseHandler implements
+ RaftClientProtocolProxy.CloseableStreamObserver {
+ private final String targetId;
+ // once handled the first NotLeaderException or Error, the handler should
+ // be inactive and should not make any further action.
+ private volatile boolean active = true;
+
+ ResponseHandler(RaftPeer target) {
+ targetId = target.getId();
+ }
+
+ @Override
+ public String toString() {
+ return AppendStreamer.this + "-ResponseHandler-" + targetId;
+ }
+
+ @Override
+ public void onNext(RaftClientReplyProto reply) {
+ if (!active) {
+ return;
+ }
+ synchronized (AppendStreamer.this) {
+ RaftClientRequestProto pending = Preconditions.checkNotNull(
+ ackQueue.peek());
+ if (reply.getRpcReply().getSuccess()) {
+ Preconditions.checkState(pending.getRpcRequest().getSeqNum() ==
+ reply.getRpcReply().getSeqNum());
+ ackQueue.poll();
+ LOG.trace("{} received success ack for request {}", this,
+ pending.getRpcRequest());
+ // we've identified the correct leader
+ if (running == RunningState.LOOK_FOR_LEADER) {
+ running = RunningState.RUNNING;
+ }
+ } else {
+ // this may be a NotLeaderException
+ RaftClientReply r = toRaftClientReply(reply);
+ if (r.isNotLeader()) {
+ LOG.debug("{} received a NotLeaderException from {}", this,
+ r.getReplierId());
+ handleNotLeader(r.getNotLeaderException(), targetId);
+ }
+ }
+ AppendStreamer.this.notifyAll();
+ }
+ }
+
+ @Override
+ public void onError(Throwable t) {
+ if (active) {
+ synchronized (AppendStreamer.this) {
+ handleError(t, this);
+ AppendStreamer.this.notifyAll();
+ }
+ }
+ }
+
+ @Override
+ public void onCompleted() {
+ LOG.info("{} onCompleted, pending requests #: {}", this,
+ ackQueue.size());
+ }
+
+ @Override // called by handleError and handleNotLeader
+ public void close() throws IOException {
+ active = false;
+ }
+ }
+
+ private void throwException(String msg) throws IOException {
+ if (running == RunningState.ERROR) {
+ throw exceptionAndRetry.getCombinedException();
+ } else {
+ throw new IOException(msg);
+ }
+ }
+
+ private void handleNotLeader(NotLeaderException nle,
+ String oldLeader) {
+ Preconditions.checkState(Thread.holdsLock(AppendStreamer.this));
+ // handle NotLeaderException: refresh leader and RaftConfiguration
+ refreshPeers(nle.getPeers());
+
+ refreshLeader(nle.getSuggestedLeader().getId(), oldLeader);
+ }
+
+ private void handleError(Throwable t, ResponseHandler handler) {
+ Preconditions.checkState(Thread.holdsLock(AppendStreamer.this));
+ final IOException e = RaftGrpcUtil.unwrapIOException(t);
+
+ exceptionAndRetry.addException(handler.targetId, e);
+ LOG.debug("{} got error: {}. Total retry times {}, max retry times {}.",
+ handler, e, exceptionAndRetry.retryTimes.get(),
+ exceptionAndRetry.maxRetryTimes);
+
+ leaderProxy.onError();
+ if (exceptionAndRetry.shouldRetry()) {
+ refreshLeader(null, leaderId);
+ } else {
+ running = RunningState.ERROR;
+ }
+ }
+
+ private void refreshLeader(String suggestedLeader, String oldLeader) {
+ running = RunningState.LOOK_FOR_LEADER;
+ refreshLeaderProxy(suggestedLeader, oldLeader);
+ reQueuePendingRequests(leaderId);
+
+ final RaftClientRequestProto request = Preconditions.checkNotNull(
+ dataQueue.poll());
+ ackQueue.offer(request);
+ try {
+ Thread.sleep(exceptionAndRetry.retryInterval);
+ } catch (InterruptedException ignored) {
+ }
+ leaderProxy.onNext(request);
+ }
+
+ private void reQueuePendingRequests(String newLeader) {
+ if (isRunning()) {
+ // resend all the pending requests
+ while (!ackQueue.isEmpty()) {
+ RaftClientRequestProto oldRequest = ackQueue.pollLast();
+ RaftRpcRequestProto r = oldRequest.getRpcRequest();
+ RaftClientRequestProto newRequest = RaftClientRequestProto.newBuilder()
+ .setMessage(oldRequest.getMessage())
+ .setReadOnly(oldRequest.getReadOnly())
+ .setRpcRequest(toRaftRpcRequestProtoBuilder(
+ clientId, newLeader, r.getSeqNum()))
+ .build();
+ dataQueue.offerFirst(newRequest);
+ }
+ }
+ }
+
+ private void refreshPeers(RaftPeer[] newPeers) {
+ if (newPeers != null && newPeers.length > 0) {
+ // we only add new peers, we do not remove any peer even if it no longer
+ // belongs to the current raft conf
+ Arrays.stream(newPeers).forEach(peer -> {
+ peers.putIfAbsent(peer.getId(), peer);
+ proxyMap.putIfAbsent(peer);
+ });
+
+ LOG.debug("refreshed peers: {}", peers);
+ }
+ }
+}
diff --git a/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/RaftClientProtocolClient.java b/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/RaftClientProtocolClient.java
new file mode 100644
index 0000000000..74fb2536f3
--- /dev/null
+++ b/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/RaftClientProtocolClient.java
@@ -0,0 +1,73 @@
+/**
+ * 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.ratis.grpc.client;
+
+import org.apache.ratis.shaded.io.grpc.ManagedChannel;
+import org.apache.ratis.shaded.io.grpc.ManagedChannelBuilder;
+import org.apache.ratis.shaded.io.grpc.StatusRuntimeException;
+import org.apache.ratis.shaded.io.grpc.stub.StreamObserver;
+import org.apache.ratis.shaded.proto.RaftProtos.RaftClientReplyProto;
+import org.apache.ratis.shaded.proto.RaftProtos.RaftClientRequestProto;
+import org.apache.ratis.shaded.proto.RaftProtos.SetConfigurationRequestProto;
+import org.apache.ratis.shaded.proto.grpc.RaftClientProtocolServiceGrpc;
+import org.apache.ratis.shaded.proto.grpc.RaftClientProtocolServiceGrpc.RaftClientProtocolServiceBlockingStub;
+import org.apache.ratis.shaded.proto.grpc.RaftClientProtocolServiceGrpc.RaftClientProtocolServiceStub;
+import org.apache.ratis.grpc.RaftGrpcUtil;
+import org.apache.ratis.protocol.RaftPeer;
+
+import java.io.Closeable;
+import java.io.IOException;
+
+public class RaftClientProtocolClient implements Closeable {
+ private final RaftPeer target;
+ private final ManagedChannel channel;
+ private final RaftClientProtocolServiceBlockingStub blockingStub;
+ private final RaftClientProtocolServiceStub asyncStub;
+
+ public RaftClientProtocolClient(RaftPeer target) {
+ this.target = target;
+ channel = ManagedChannelBuilder.forTarget(target.getAddress())
+ .usePlaintext(true).build();
+ blockingStub = RaftClientProtocolServiceGrpc.newBlockingStub(channel);
+ asyncStub = RaftClientProtocolServiceGrpc.newStub(channel);
+ }
+
+ @Override
+ public void close() {
+ channel.shutdownNow();
+ }
+
+ public RaftClientReplyProto setConfiguration(
+ SetConfigurationRequestProto request) throws IOException {
+ try {
+ return blockingStub.setConfiguration(request);
+ } catch (StatusRuntimeException e) {
+ // unwrap StatusRuntimeException
+ throw RaftGrpcUtil.unwrapException(e);
+ }
+ }
+
+ StreamObserver append(
+ StreamObserver responseHandler) {
+ return asyncStub.append(responseHandler);
+ }
+
+ public RaftPeer getTarget() {
+ return target;
+ }
+}
diff --git a/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/RaftClientProtocolProxy.java b/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/RaftClientProtocolProxy.java
new file mode 100644
index 0000000000..6892c71fb4
--- /dev/null
+++ b/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/RaftClientProtocolProxy.java
@@ -0,0 +1,104 @@
+/**
+ * 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.ratis.grpc.client;
+
+import org.apache.ratis.shaded.io.grpc.stub.StreamObserver;
+import org.apache.ratis.shaded.proto.RaftProtos.RaftClientReplyProto;
+import org.apache.ratis.shaded.proto.RaftProtos.RaftClientRequestProto;
+import org.apache.ratis.protocol.RaftPeer;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.function.Function;
+
+public class RaftClientProtocolProxy implements Closeable {
+ private final RaftClientProtocolClient proxy;
+ private final Function responseHandlerCreation;
+ private RpcSession currentSession;
+
+ public RaftClientProtocolProxy(RaftPeer target,
+ Function responseHandlerCreation) {
+ proxy = new RaftClientProtocolClient(target);
+ this.responseHandlerCreation = responseHandlerCreation;
+ }
+
+ @Override
+ public void close() throws IOException {
+ closeCurrentSession();
+ proxy.close();
+ }
+
+ @Override
+ public String toString() {
+ return "ProxyTo:" + proxy.getTarget();
+ }
+
+ public void closeCurrentSession() {
+ if (currentSession != null) {
+ currentSession.close();
+ currentSession = null;
+ }
+ }
+
+ public void onNext(RaftClientRequestProto request) {
+ if (currentSession == null) {
+ currentSession = new RpcSession(
+ responseHandlerCreation.apply(proxy.getTarget()));
+ }
+ currentSession.requestObserver.onNext(request);
+ }
+
+ public void onError() {
+ if (currentSession != null) {
+ currentSession.onError();
+ }
+ }
+
+ public interface CloseableStreamObserver
+ extends StreamObserver, Closeable {
+ }
+
+ class RpcSession implements Closeable {
+ private final StreamObserver requestObserver;
+ private final CloseableStreamObserver responseHandler;
+ private boolean hasError = false;
+
+ RpcSession(CloseableStreamObserver responseHandler) {
+ this.responseHandler = responseHandler;
+ this.requestObserver = proxy.append(responseHandler);
+ }
+
+ void onError() {
+ hasError = true;
+ }
+
+ @Override
+ public void close() {
+ if (!hasError) {
+ try {
+ requestObserver.onCompleted();
+ } catch (Exception ignored) {
+ }
+ }
+ try {
+ responseHandler.close();
+ } catch (IOException ignored) {
+ }
+ }
+ }
+}
diff --git a/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/RaftClientProtocolService.java b/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/RaftClientProtocolService.java
new file mode 100644
index 0000000000..bb212e1d4b
--- /dev/null
+++ b/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/RaftClientProtocolService.java
@@ -0,0 +1,195 @@
+/**
+ * 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.ratis.grpc.client;
+
+import com.google.common.base.Preconditions;
+
+import org.apache.ratis.shaded.io.grpc.stub.StreamObserver;
+import org.apache.ratis.shaded.proto.RaftProtos.RaftClientReplyProto;
+import org.apache.ratis.shaded.proto.RaftProtos.RaftClientRequestProto;
+import org.apache.ratis.shaded.proto.RaftProtos.SetConfigurationRequestProto;
+import org.apache.ratis.shaded.proto.grpc.RaftClientProtocolServiceGrpc.RaftClientProtocolServiceImplBase;
+import org.apache.ratis.client.impl.ClientProtoUtils;
+import org.apache.ratis.grpc.RaftGrpcUtil;
+import org.apache.ratis.protocol.RaftClientAsynchronousProtocol;
+import org.apache.ratis.protocol.RaftClientReply;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+
+public class RaftClientProtocolService extends RaftClientProtocolServiceImplBase {
+ static final Logger LOG = LoggerFactory.getLogger(RaftClientProtocolService.class);
+
+ private static class PendingAppend implements Comparable {
+ private final long seqNum;
+ private volatile RaftClientReply reply;
+
+ PendingAppend(long seqNum) {
+ this.seqNum = seqNum;
+ }
+
+ boolean isReady() {
+ return reply != null || this == COMPLETED;
+ }
+
+ void setReply(RaftClientReply reply) {
+ this.reply = reply;
+ }
+
+ @Override
+ public int compareTo(PendingAppend p) {
+ return seqNum == p.seqNum ? 0 : (seqNum < p.seqNum ? -1 : 1);
+ }
+
+ @Override
+ public String toString() {
+ return seqNum + ", reply:" + (reply == null ? "null" : reply.toString());
+ }
+ }
+ private static final PendingAppend COMPLETED = new PendingAppend(Long.MAX_VALUE);
+
+ private final String id;
+ private final RaftClientAsynchronousProtocol client;
+
+ public RaftClientProtocolService(String id, RaftClientAsynchronousProtocol client) {
+ this.id = id;
+ this.client = client;
+ }
+
+ @Override
+ public void setConfiguration(SetConfigurationRequestProto request,
+ StreamObserver responseObserver) {
+ try {
+ CompletableFuture future = client.setConfigurationAsync(
+ ClientProtoUtils.toSetConfigurationRequest(request));
+ future.whenCompleteAsync((reply, exception) -> {
+ if (exception != null) {
+ responseObserver.onError(RaftGrpcUtil.wrapException(exception));
+ } else {
+ responseObserver.onNext(ClientProtoUtils.toRaftClientReplyProto(reply));
+ responseObserver.onCompleted();
+ }
+ });
+ } catch (Exception e) {
+ responseObserver.onError(RaftGrpcUtil.wrapException(e));
+ }
+ }
+
+ @Override
+ public StreamObserver append(
+ StreamObserver responseObserver) {
+ return new AppendRequestStreamObserver(responseObserver);
+ }
+
+ private class AppendRequestStreamObserver implements
+ StreamObserver {
+ private final List pendingList = new LinkedList<>();
+ private final StreamObserver responseObserver;
+
+ AppendRequestStreamObserver(StreamObserver ro) {
+ this.responseObserver = ro;
+ }
+
+ @Override
+ public void onNext(RaftClientRequestProto request) {
+ try {
+ PendingAppend p = new PendingAppend(request.getRpcRequest().getSeqNum());
+ synchronized (pendingList) {
+ pendingList.add(p);
+ }
+
+ CompletableFuture future = client.submitClientRequestAsync(
+ ClientProtoUtils.toRaftClientRequest(request));
+ future.whenCompleteAsync((reply, exception) -> {
+ if (exception != null) {
+ // TODO: the exception may be from either raft or state machine.
+ // Currently we skip all the following responses when getting an
+ // exception from the state machine.
+ responseObserver.onError(RaftGrpcUtil.wrapException(exception));
+ } else {
+ final long replySeq = reply.getSeqNum();
+ synchronized (pendingList) {
+ Preconditions.checkState(!pendingList.isEmpty(),
+ "PendingList is empty when handling onNext for seqNum %s",
+ replySeq);
+ final long headSeqNum = pendingList.get(0).seqNum;
+ // we assume the seqNum is consecutive for a stream RPC call
+ final PendingAppend pendingForReply = pendingList.get(
+ (int) (replySeq - headSeqNum));
+ Preconditions.checkState(pendingForReply != null &&
+ pendingForReply.seqNum == replySeq,
+ "pending for reply is: %s, the pending list: %s",
+ pendingForReply, pendingList);
+ pendingForReply.setReply(reply);
+
+ if (headSeqNum == replySeq) {
+ Collection readySet = new ArrayList<>();
+ // if this is head, we send back all the ready responses
+ Iterator iter = pendingList.iterator();
+ PendingAppend pending;
+ while (iter.hasNext() && ((pending = iter.next()).isReady())) {
+ readySet.add(pending);
+ iter.remove();
+ }
+ sendReadyReplies(readySet);
+ }
+ }
+ }
+ });
+ } catch (Throwable e) {
+ LOG.info("{} got exception when handling client append request {}: {}",
+ id, request.getRpcRequest(), e);
+ responseObserver.onError(RaftGrpcUtil.wrapException(e));
+ }
+ }
+
+ private void sendReadyReplies(Collection readySet) {
+ readySet.forEach(ready -> {
+ Preconditions.checkState(ready.isReady());
+ if (ready == COMPLETED) {
+ responseObserver.onCompleted();
+ } else {
+ responseObserver.onNext(
+ ClientProtoUtils.toRaftClientReplyProto(ready.reply));
+ }
+ });
+ }
+
+ @Override
+ public void onError(Throwable t) {
+ // for now we just log a msg
+ LOG.warn("{} onError: client Append cancelled", id, t);
+ synchronized (pendingList) {
+ pendingList.clear();
+ }
+ }
+
+ @Override
+ public void onCompleted() {
+ synchronized (pendingList) {
+ if (pendingList.isEmpty()) {
+ responseObserver.onCompleted();
+ } else {
+ pendingList.add(COMPLETED);
+ }
+ }
+ }
+ }
+}
diff --git a/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/RaftClientSenderWithGrpc.java b/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/RaftClientSenderWithGrpc.java
new file mode 100644
index 0000000000..6d9e11f92d
--- /dev/null
+++ b/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/RaftClientSenderWithGrpc.java
@@ -0,0 +1,119 @@
+/**
+ * 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.ratis.grpc.client;
+
+import org.apache.ratis.shaded.io.grpc.StatusRuntimeException;
+import org.apache.ratis.shaded.io.grpc.stub.StreamObserver;
+import org.apache.ratis.shaded.proto.RaftProtos.RaftClientReplyProto;
+import org.apache.ratis.shaded.proto.RaftProtos.RaftClientRequestProto;
+import org.apache.ratis.shaded.proto.RaftProtos.SetConfigurationRequestProto;
+import org.apache.ratis.client.RaftClientRequestSender;
+import org.apache.ratis.grpc.RaftGrpcUtil;
+import org.apache.ratis.protocol.RaftClientReply;
+import org.apache.ratis.protocol.RaftClientRequest;
+import org.apache.ratis.protocol.RaftPeer;
+import org.apache.ratis.protocol.SetConfigurationRequest;
+import org.apache.ratis.util.PeerProxyMap;
+import org.apache.ratis.util.RaftUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.apache.ratis.client.impl.ClientProtoUtils.*;
+
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.util.Collection;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+public class RaftClientSenderWithGrpc implements RaftClientRequestSender {
+ public static final Logger LOG = LoggerFactory.getLogger(RaftClientSenderWithGrpc.class);
+
+ private final PeerProxyMap proxies
+ = new PeerProxyMap<>(RaftClientProtocolClient::new);
+
+ public RaftClientSenderWithGrpc(Collection peers) {
+ addServers(peers);
+ }
+
+ @Override
+ public RaftClientReply sendRequest(RaftClientRequest request)
+ throws IOException {
+ final String serverId = request.getReplierId();
+ final RaftClientProtocolClient proxy = proxies.getProxy(serverId);
+ if (request instanceof SetConfigurationRequest) {
+ SetConfigurationRequestProto setConf =
+ toSetConfigurationRequestProto((SetConfigurationRequest) request);
+ return toRaftClientReply(proxy.setConfiguration(setConf));
+ } else {
+ RaftClientRequestProto requestProto = toRaftClientRequestProto(request);
+ CompletableFuture replyFuture =
+ new CompletableFuture<>();
+ final StreamObserver requestObserver =
+ proxy.append(new StreamObserver() {
+ @Override
+ public void onNext(RaftClientReplyProto value) {
+ replyFuture.complete(value);
+ }
+
+ @Override
+ public void onError(Throwable t) {
+ // This implementation is used as RaftClientRequestSender. Retry
+ // logic on Exception is in RaftClient.
+ final IOException e;
+ if (t instanceof StatusRuntimeException) {
+ e = RaftGrpcUtil.unwrapException((StatusRuntimeException) t);
+ } else {
+ e = RaftUtils.asIOException(t);
+ }
+ replyFuture.completeExceptionally(e);
+ }
+
+ @Override
+ public void onCompleted() {
+ if (!replyFuture.isDone()) {
+ replyFuture.completeExceptionally(
+ new IOException("No reply for request " + request));
+ }
+ }
+ });
+ requestObserver.onNext(requestProto);
+ requestObserver.onCompleted();
+
+ // TODO: timeout support
+ try {
+ return toRaftClientReply(replyFuture.get());
+ } catch (InterruptedException e) {
+ throw new InterruptedIOException(
+ "Interrupted while waiting for response of request " + request);
+ } catch (ExecutionException e) {
+ throw RaftUtils.toIOException(e);
+ }
+ }
+ }
+
+ @Override
+ public void addServers(Iterable servers) {
+ proxies.addPeers(servers);
+ }
+
+ @Override
+ public void close() throws IOException {
+ proxies.close();
+ }
+}
diff --git a/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/RaftOutputStream.java b/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/RaftOutputStream.java
new file mode 100644
index 0000000000..a3905f82e8
--- /dev/null
+++ b/ratis-grpc/src/main/java/org/apache/ratis/grpc/client/RaftOutputStream.java
@@ -0,0 +1,112 @@
+/**
+ * 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.ratis.grpc.client;
+
+import static org.apache.ratis.grpc.RaftGrpcConfigKeys.RAFT_OUTPUTSTREAM_BUFFER_SIZE_DEFAULT;
+import static org.apache.ratis.grpc.RaftGrpcConfigKeys.RAFT_OUTPUTSTREAM_BUFFER_SIZE_KEY;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Collection;
+
+import org.apache.ratis.conf.RaftProperties;
+import org.apache.ratis.protocol.RaftPeer;
+import org.apache.ratis.util.ProtoUtils;
+
+public class RaftOutputStream extends OutputStream {
+ /** internal buffer */
+ private final byte buf[];
+ private int count;
+ private long seqNum = 0;
+ private final String clientId;
+ private final AppendStreamer streamer;
+
+ private boolean closed = false;
+
+ public RaftOutputStream(RaftProperties prop, String clientId,
+ Collection peers, String leaderId) {
+ final int bufferSize = prop.getInt(RAFT_OUTPUTSTREAM_BUFFER_SIZE_KEY,
+ RAFT_OUTPUTSTREAM_BUFFER_SIZE_DEFAULT);
+ buf = new byte[bufferSize];
+ count = 0;
+ this.clientId = clientId;
+ streamer = new AppendStreamer(prop, peers, leaderId, clientId);
+ }
+
+ @Override
+ public void write(int b) throws IOException {
+ checkClosed();
+ buf[count++] = (byte)b;
+ flushIfNecessary();
+ }
+
+ private void flushIfNecessary() throws IOException {
+ if(count == buf.length) {
+ flushToStreamer();
+ }
+ }
+
+ @Override
+ public void write(byte b[], int off, int len) throws IOException {
+ checkClosed();
+ if (off < 0 || len < 0 || off > b.length - len) {
+ throw new ArrayIndexOutOfBoundsException();
+ }
+
+ int total = 0;
+ while (total < len) {
+ int toWrite = Math.min(len - total, buf.length - count);
+ System.arraycopy(b, off + total, buf, count, toWrite);
+ count += toWrite;
+ total += toWrite;
+ flushIfNecessary();
+ }
+ }
+
+ private void flushToStreamer() throws IOException {
+ if (count > 0) {
+ streamer.write(ProtoUtils.toByteString(buf, 0, count), seqNum++);
+ count = 0;
+ }
+ }
+
+ @Override
+ public void flush() throws IOException {
+ checkClosed();
+ flushToStreamer();
+ streamer.flush();
+ }
+
+ @Override
+ public void close() throws IOException {
+ flushToStreamer();
+ streamer.close(); // streamer will flush
+ this.closed = true;
+ }
+
+ @Override
+ public String toString() {
+ return "RaftOutputStream-" + clientId;
+ }
+
+ private void checkClosed() throws IOException {
+ if (closed) {
+ throw new IOException(this.toString() + " was closed.");
+ }
+ }
+}
diff --git a/ratis-grpc/src/main/java/org/apache/ratis/grpc/server/GRpcLogAppender.java b/ratis-grpc/src/main/java/org/apache/ratis/grpc/server/GRpcLogAppender.java
new file mode 100644
index 0000000000..5f1d9015a8
--- /dev/null
+++ b/ratis-grpc/src/main/java/org/apache/ratis/grpc/server/GRpcLogAppender.java
@@ -0,0 +1,416 @@
+/**
+ * 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.ratis.grpc.server;
+
+import com.google.common.base.Preconditions;
+
+import org.apache.ratis.shaded.io.grpc.Status;
+import org.apache.ratis.shaded.io.grpc.stub.StreamObserver;
+import org.apache.ratis.shaded.proto.RaftProtos.AppendEntriesReplyProto;
+import org.apache.ratis.shaded.proto.RaftProtos.AppendEntriesRequestProto;
+import org.apache.ratis.shaded.proto.RaftProtos.InstallSnapshotReplyProto;
+import org.apache.ratis.shaded.proto.RaftProtos.InstallSnapshotRequestProto;
+import org.apache.ratis.grpc.RaftGRpcService;
+import org.apache.ratis.grpc.RaftGrpcConfigKeys;
+import org.apache.ratis.server.impl.FollowerInfo;
+import org.apache.ratis.server.impl.LeaderState;
+import org.apache.ratis.server.impl.LogAppender;
+import org.apache.ratis.server.impl.RaftServerImpl;
+import org.apache.ratis.statemachine.SnapshotInfo;
+import org.apache.ratis.util.CodeInjectionForTesting;
+
+import static org.apache.ratis.grpc.RaftGRpcService.GRPC_SEND_SERVER_REQUEST;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * A new log appender implementation using grpc bi-directional stream API.
+ */
+public class GRpcLogAppender extends LogAppender {
+ private final RaftServerProtocolClient client;
+ private final Queue pendingRequests;
+ private final int maxPendingRequestsNum;
+ private volatile boolean firstResponseReceived = false;
+
+ private final AppendLogResponseHandler appendResponseHandler;
+ private final InstallSnapshotResponseHandler snapshotResponseHandler;
+
+ private volatile StreamObserver appendLogRequestObserver;
+ private StreamObserver snapshotRequestObserver;
+
+ public GRpcLogAppender(RaftServerImpl server, LeaderState leaderState,
+ FollowerInfo f) {
+ super(server, leaderState, f);
+
+ RaftGRpcService rpcService = (RaftGRpcService) server.getServerRpc();
+ client = rpcService.getRpcClient(f.getPeer());
+ maxPendingRequestsNum = server.getProperties().getInt(
+ RaftGrpcConfigKeys.RAFT_GRPC_LEADER_MAX_OUTSTANDING_APPENDS_KEY,
+ RaftGrpcConfigKeys.RAFT_GRPC_LEADER_MAX_OUTSTANDING_APPENDS_DEFAULT);
+ pendingRequests = new ConcurrentLinkedQueue<>();
+
+ appendResponseHandler = new AppendLogResponseHandler();
+ snapshotResponseHandler = new InstallSnapshotResponseHandler();
+ }
+
+ @Override
+ public void run() {
+ while (isAppenderRunning()) {
+ if (shouldSendRequest()) {
+ SnapshotInfo snapshot = shouldInstallSnapshot();
+ if (snapshot != null) {
+ installSnapshot(snapshot, snapshotResponseHandler);
+ } else {
+ // keep appending log entries or sending heartbeats
+ appendLog();
+ }
+ }
+
+ if (isAppenderRunning() && !shouldSendRequest()) {
+ // use lastSend time instead of lastResponse time
+ final long waitTime = getHeartbeatRemainingTime(
+ follower.getLastRpcTime());
+ if (waitTime > 0) {
+ synchronized (this) {
+ try {
+ LOG.debug("{} decides to wait {}ms before appending to {}",
+ server.getId(), waitTime, follower.getPeer());
+ wait(waitTime);
+ } catch (InterruptedException ignored) {
+ }
+ }
+ }
+ }
+ }
+ appendLogRequestObserver.onCompleted();
+ }
+
+ private boolean shouldWait() {
+ return pendingRequests.size() >= maxPendingRequestsNum ||
+ shouldWaitForFirstResponse();
+ }
+
+ private void appendLog() {
+ if (appendLogRequestObserver == null) {
+ appendLogRequestObserver = client.appendEntries(appendResponseHandler);
+ }
+ AppendEntriesRequestProto pending = null;
+ final StreamObserver s;
+ synchronized (this) {
+ // if the queue's size >= maxSize, wait
+ while (isAppenderRunning() && shouldWait()) {
+ try {
+ LOG.debug("{} wait to send the next AppendEntries to {}",
+ server.getId(), follower.getPeer());
+ this.wait();
+ } catch (InterruptedException ignored) {
+ }
+ }
+
+ if (isAppenderRunning()) {
+ // prepare and enqueue the append request. note changes on follower's
+ // nextIndex and ops on pendingRequests should always be associated
+ // together and protected by the lock
+ pending = createRequest();
+ if (pending != null) {
+ Preconditions.checkState(pendingRequests.offer(pending));
+ updateNextIndex(pending);
+ }
+ }
+ s = appendLogRequestObserver;
+ }
+
+ if (pending != null && isAppenderRunning()) {
+ sendRequest(pending, s);
+ }
+ }
+
+ private void sendRequest(AppendEntriesRequestProto request,
+ StreamObserver s) {
+ CodeInjectionForTesting.execute(GRPC_SEND_SERVER_REQUEST, server.getId(),
+ null, request);
+
+ s.onNext(request);
+ follower.updateLastRpcSendTime();
+ }
+
+ private void updateNextIndex(AppendEntriesRequestProto request) {
+ final int count = request.getEntriesCount();
+ if (count > 0) {
+ follower.updateNextIndex(request.getEntries(count - 1).getIndex() + 1);
+ }
+ }
+
+ /**
+ * if this is the first append, wait for the response of the first append so
+ * that we can get the correct next index.
+ */
+ private boolean shouldWaitForFirstResponse() {
+ return pendingRequests.size() > 0 && !firstResponseReceived;
+ }
+
+ /**
+ * StreamObserver for handling responses from the follower
+ */
+ private class AppendLogResponseHandler
+ implements StreamObserver {
+ /**
+ * After receiving a appendEntries reply, do the following:
+ * 1. If the reply is success, update the follower's match index and submit
+ * an event to leaderState
+ * 2. If the reply is NOT_LEADER, step down
+ * 3. If the reply is INCONSISTENCY, decrease the follower's next index
+ * based on the response
+ */
+ @Override
+ public void onNext(AppendEntriesReplyProto reply) {
+ LOG.debug("{} received {} response from {}", server.getId(),
+ (!firstResponseReceived ? "the first" : "a"),
+ follower.getPeer());
+
+ // update the last rpc time
+ follower.updateLastRpcResponseTime();
+
+ if (!firstResponseReceived) {
+ firstResponseReceived = true;
+ }
+ switch (reply.getResult()) {
+ case SUCCESS:
+ onSuccess(reply);
+ break;
+ case NOT_LEADER:
+ onNotLeader(reply);
+ break;
+ case INCONSISTENCY:
+ onInconsistency(reply);
+ break;
+ default:
+ break;
+ }
+ notifyAppend();
+ }
+
+ /**
+ * for now we simply retry the first pending request
+ */
+ @Override
+ public void onError(Throwable t) {
+ if (!isAppenderRunning()) {
+ LOG.info("{} is stopped", GRpcLogAppender.this);
+ return;
+ }
+ LOG.warn("{} got error when appending entries to {}, exception: {}.",
+ server.getId(), follower.getPeer().getId(), t);
+
+ synchronized (this) {
+ final Status cause = Status.fromThrowable(t);
+ if (cause != null && cause.getCode() == Status.Code.INTERNAL) {
+ // TODO check other Status. Add sleep to avoid tight loop
+ LOG.debug("{} restarts Append call to {} due to error {}",
+ server.getId(), follower.getPeer(), t);
+ // recreate the StreamObserver
+ appendLogRequestObserver = client.appendEntries(appendResponseHandler);
+ // reset firstResponseReceived to false
+ firstResponseReceived = false;
+ }
+
+ // clear the pending requests queue and reset the next index of follower
+ AppendEntriesRequestProto request = pendingRequests.peek();
+ if (request != null) {
+ final long nextIndex = request.hasPreviousLog() ?
+ request.getPreviousLog().getIndex() + 1 : raftLog.getStartIndex();
+ clearPendingRequests(nextIndex);
+ }
+ }
+ }
+
+ @Override
+ public void onCompleted() {
+ LOG.info("{} stops appending log entries to follower {}", server.getId(),
+ follower);
+ }
+ }
+
+ private void clearPendingRequests(long newNextIndex) {
+ pendingRequests.clear();
+ follower.decreaseNextIndex(newNextIndex);
+ }
+
+ private void onSuccess(AppendEntriesReplyProto reply) {
+ AppendEntriesRequestProto request = pendingRequests.poll();
+ final long replyNextIndex = reply.getNextIndex();
+ Preconditions.checkNotNull(request,
+ "Got reply with next index %s but the pending queue is empty",
+ replyNextIndex);
+
+ if (request.getEntriesCount() == 0) {
+ Preconditions.checkState(!request.hasPreviousLog() ||
+ replyNextIndex - 1 == request.getPreviousLog().getIndex(),
+ "reply's next index is %s, request's previous is %s",
+ replyNextIndex, request.getPreviousLog());
+ } else {
+ // check if the reply and the pending request is consistent
+ final long lastEntryIndex = request
+ .getEntries(request.getEntriesCount() - 1).getIndex();
+ Preconditions.checkState(replyNextIndex == lastEntryIndex + 1,
+ "reply's next index is %s, request's last entry index is %s",
+ replyNextIndex, lastEntryIndex);
+ follower.updateMatchIndex(lastEntryIndex);
+ submitEventOnSuccessAppend();
+ }
+ }
+
+ private void onNotLeader(AppendEntriesReplyProto reply) {
+ checkResponseTerm(reply.getTerm());
+ // the running loop will end and the connection will onComplete
+ }
+
+ private synchronized void onInconsistency(AppendEntriesReplyProto reply) {
+ AppendEntriesRequestProto request = pendingRequests.peek();
+ Preconditions.checkState(request.hasPreviousLog());
+ if (request.getPreviousLog().getIndex() >= reply.getNextIndex()) {
+ clearPendingRequests(reply.getNextIndex());
+ }
+ }
+
+ private class InstallSnapshotResponseHandler
+ implements StreamObserver {
+ private final Queue pending;
+ private final AtomicBoolean done = new AtomicBoolean(false);
+
+ InstallSnapshotResponseHandler() {
+ pending = new LinkedList<>();
+ }
+
+ synchronized void addPending(InstallSnapshotRequestProto request) {
+ pending.offer(request.getRequestIndex());
+ }
+
+ synchronized void removePending(InstallSnapshotReplyProto reply) {
+ int index = pending.poll();
+ Preconditions.checkState(index == reply.getRequestIndex());
+ }
+
+ boolean isDone() {
+ return done.get();
+ }
+
+ void close() {
+ done.set(true);
+ GRpcLogAppender.this.notifyAppend();
+ }
+
+ synchronized boolean hasAllResponse() {
+ return pending.isEmpty();
+ }
+
+ @Override
+ public void onNext(InstallSnapshotReplyProto reply) {
+ LOG.debug("{} received {} response from {}", server.getId(),
+ (!firstResponseReceived ? "the first" : "a"),
+ follower.getPeer());
+
+ // update the last rpc time
+ follower.updateLastRpcResponseTime();
+
+ if (!firstResponseReceived) {
+ firstResponseReceived = true;
+ }
+
+ switch (reply.getResult()) {
+ case SUCCESS:
+ removePending(reply);
+ break;
+ case NOT_LEADER:
+ checkResponseTerm(reply.getTerm());
+ break;
+ case UNRECOGNIZED:
+ break;
+ }
+ }
+
+ @Override
+ public void onError(Throwable t) {
+ if (!isAppenderRunning()) {
+ LOG.info("{} is stopped", GRpcLogAppender.this);
+ return;
+ }
+ LOG.info("{} got error when installing snapshot to {}, exception: {}",
+ server.getId(), follower.getPeer(), t);
+ close();
+ }
+
+ @Override
+ public void onCompleted() {
+ LOG.info("{} stops sending snapshots to follower {}", server.getId(),
+ follower);
+ close();
+ }
+ }
+
+ private void installSnapshot(SnapshotInfo snapshot,
+ InstallSnapshotResponseHandler responseHandler) {
+ LOG.info("{}: follower {}'s next index is {}," +
+ " log's start index is {}, need to install snapshot",
+ server.getId(), follower.getPeer(), follower.getNextIndex(),
+ raftLog.getStartIndex());
+
+ snapshotRequestObserver = client.installSnapshot(snapshotResponseHandler);
+ final String requestId = UUID.randomUUID().toString();
+ try {
+ for (InstallSnapshotRequestProto request :
+ new SnapshotRequestIter(snapshot, requestId)) {
+ if (isAppenderRunning()) {
+ snapshotRequestObserver.onNext(request);
+ follower.updateLastRpcSendTime();
+ responseHandler.addPending(request);
+ } else {
+ break;
+ }
+ }
+ snapshotRequestObserver.onCompleted();
+ } catch (Exception e) {
+ LOG.warn("{} failed to install snapshot {}. Exception: {}", this,
+ snapshot.getFiles(), e);
+ snapshotRequestObserver.onError(e);
+ return;
+ } finally {
+ snapshotRequestObserver = null;
+ }
+
+ synchronized (this) {
+ while (isAppenderRunning() && !responseHandler.isDone()) {
+ try {
+ wait();
+ } catch (InterruptedException ignored) {
+ }
+ }
+ }
+
+ if (responseHandler.hasAllResponse()) {
+ follower.updateMatchIndex(snapshot.getTermIndex().getIndex());
+ follower.updateNextIndex(snapshot.getTermIndex().getIndex() + 1);
+ LOG.info("{}: install snapshot-{} successfully on follower {}",
+ server.getId(), snapshot.getTermIndex().getIndex(), follower.getPeer());
+ }
+ }
+}
diff --git a/ratis-grpc/src/main/java/org/apache/ratis/grpc/server/PipelinedLogAppenderFactory.java b/ratis-grpc/src/main/java/org/apache/ratis/grpc/server/PipelinedLogAppenderFactory.java
new file mode 100644
index 0000000000..d30b391239
--- /dev/null
+++ b/ratis-grpc/src/main/java/org/apache/ratis/grpc/server/PipelinedLogAppenderFactory.java
@@ -0,0 +1,32 @@
+/**
+ * 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.ratis.grpc.server;
+
+import org.apache.ratis.server.impl.FollowerInfo;
+import org.apache.ratis.server.impl.LeaderState;
+import org.apache.ratis.server.impl.LogAppender;
+import org.apache.ratis.server.impl.LogAppenderFactory;
+import org.apache.ratis.server.impl.RaftServerImpl;
+
+public class PipelinedLogAppenderFactory implements LogAppenderFactory {
+ @Override
+ public LogAppender getLogAppender(RaftServerImpl server, LeaderState state,
+ FollowerInfo f) {
+ return new GRpcLogAppender(server, state, f);
+ }
+}
diff --git a/ratis-grpc/src/main/java/org/apache/ratis/grpc/server/RaftServerProtocolClient.java b/ratis-grpc/src/main/java/org/apache/ratis/grpc/server/RaftServerProtocolClient.java
new file mode 100644
index 0000000000..53df10d9ad
--- /dev/null
+++ b/ratis-grpc/src/main/java/org/apache/ratis/grpc/server/RaftServerProtocolClient.java
@@ -0,0 +1,63 @@
+/**
+ * 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.ratis.grpc.server;
+
+import org.apache.ratis.shaded.io.grpc.ManagedChannel;
+import org.apache.ratis.shaded.io.grpc.ManagedChannelBuilder;
+import org.apache.ratis.shaded.io.grpc.stub.StreamObserver;
+import org.apache.ratis.shaded.proto.RaftProtos.*;
+import org.apache.ratis.shaded.proto.grpc.RaftServerProtocolServiceGrpc;
+import org.apache.ratis.shaded.proto.grpc.RaftServerProtocolServiceGrpc.RaftServerProtocolServiceBlockingStub;
+import org.apache.ratis.shaded.proto.grpc.RaftServerProtocolServiceGrpc.RaftServerProtocolServiceStub;
+import org.apache.ratis.protocol.RaftPeer;
+
+/**
+ * This is a RaftClient implementation that supports streaming data to the raft
+ * ring. The stream implementation utilizes gRPC.
+ */
+public class RaftServerProtocolClient {
+ private final ManagedChannel channel;
+ private final RaftServerProtocolServiceBlockingStub blockingStub;
+ private final RaftServerProtocolServiceStub asyncStub;
+
+ public RaftServerProtocolClient(RaftPeer target) {
+ channel = ManagedChannelBuilder.forTarget(target.getAddress())
+ .usePlaintext(true).build();
+ blockingStub = RaftServerProtocolServiceGrpc.newBlockingStub(channel);
+ asyncStub = RaftServerProtocolServiceGrpc.newStub(channel);
+ }
+
+ public void shutdown() {
+ channel.shutdownNow();
+ }
+
+ public RequestVoteReplyProto requestVote(RequestVoteRequestProto request) {
+ // the StatusRuntimeException will be handled by the caller
+ return blockingStub.requestVote(request);
+ }
+
+ StreamObserver appendEntries(
+ StreamObserver responseHandler) {
+ return asyncStub.appendEntries(responseHandler);
+ }
+
+ StreamObserver installSnapshot(
+ StreamObserver responseHandler) {
+ return asyncStub.installSnapshot(responseHandler);
+ }
+}
diff --git a/ratis-grpc/src/main/java/org/apache/ratis/grpc/server/RaftServerProtocolService.java b/ratis-grpc/src/main/java/org/apache/ratis/grpc/server/RaftServerProtocolService.java
new file mode 100644
index 0000000000..08e6a51574
--- /dev/null
+++ b/ratis-grpc/src/main/java/org/apache/ratis/grpc/server/RaftServerProtocolService.java
@@ -0,0 +1,116 @@
+/**
+ * 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.ratis.grpc.server;
+
+import org.apache.ratis.grpc.RaftGrpcUtil;
+import org.apache.ratis.server.protocol.RaftServerProtocol;
+import org.apache.ratis.shaded.io.grpc.stub.StreamObserver;
+import org.apache.ratis.shaded.proto.RaftProtos.AppendEntriesReplyProto;
+import org.apache.ratis.shaded.proto.RaftProtos.AppendEntriesRequestProto;
+import org.apache.ratis.shaded.proto.RaftProtos.InstallSnapshotReplyProto;
+import org.apache.ratis.shaded.proto.RaftProtos.InstallSnapshotRequestProto;
+import org.apache.ratis.shaded.proto.RaftProtos.RequestVoteReplyProto;
+import org.apache.ratis.shaded.proto.RaftProtos.RequestVoteRequestProto;
+import org.apache.ratis.shaded.proto.grpc.RaftServerProtocolServiceGrpc.RaftServerProtocolServiceImplBase;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class RaftServerProtocolService extends RaftServerProtocolServiceImplBase {
+ public static final Logger LOG = LoggerFactory.getLogger(RaftServerProtocolService.class);
+
+ private final String id;
+ private final RaftServerProtocol server;
+
+ public RaftServerProtocolService(String id, RaftServerProtocol server) {
+ this.id = id;
+ this.server = server;
+ }
+
+ @Override
+ public void requestVote(RequestVoteRequestProto request,
+ StreamObserver responseObserver) {
+ try {
+ final RequestVoteReplyProto reply = server.requestVote(request);
+ responseObserver.onNext(reply);
+ responseObserver.onCompleted();
+ } catch (Throwable e) {
+ LOG.info("{} got exception when handling requestVote {}: {}",
+ id, request.getServerRequest(), e);
+ responseObserver.onError(RaftGrpcUtil.wrapException(e));
+ }
+ }
+
+ @Override
+ public StreamObserver appendEntries(
+ StreamObserver responseObserver) {
+ return new StreamObserver() {
+ @Override
+ public void onNext(AppendEntriesRequestProto request) {
+ try {
+ final AppendEntriesReplyProto reply = server.appendEntries(request);
+ responseObserver.onNext(reply);
+ } catch (Throwable e) {
+ LOG.info("{} got exception when handling appendEntries {}: {}",
+ id, request.getServerRequest(), e);
+ responseObserver.onError(RaftGrpcUtil.wrapException(e));
+ }
+ }
+
+ @Override
+ public void onError(Throwable t) {
+ // for now we just log a msg
+ LOG.info("{}: appendEntries on error. Exception: {}", id, t);
+ }
+
+ @Override
+ public void onCompleted() {
+ LOG.info("{}: appendEntries completed", id);
+ responseObserver.onCompleted();
+ }
+ };
+ }
+
+ @Override
+ public StreamObserver installSnapshot(
+ StreamObserver responseObserver) {
+ return new StreamObserver() {
+ @Override
+ public void onNext(InstallSnapshotRequestProto request) {
+ try {
+ final InstallSnapshotReplyProto reply = server.installSnapshot(request);
+ responseObserver.onNext(reply);
+ } catch (Throwable e) {
+ LOG.info("{} got exception when handling installSnapshot {}: {}",
+ id, request.getServerRequest(), e);
+ responseObserver.onError(RaftGrpcUtil.wrapException(e));
+ }
+ }
+
+ @Override
+ public void onError(Throwable t) {
+ LOG.info("{}: installSnapshot on error. Exception: {}", id, t);
+ }
+
+ @Override
+ public void onCompleted() {
+ LOG.info("{}: installSnapshot completed", id);
+ responseObserver.onCompleted();
+ }
+ };
+ }
+}
diff --git a/ratis-grpc/src/test/java/org/apache/ratis/grpc/MiniRaftClusterWithGRpc.java b/ratis-grpc/src/test/java/org/apache/ratis/grpc/MiniRaftClusterWithGRpc.java
new file mode 100644
index 0000000000..7a996eb2f6
--- /dev/null
+++ b/ratis-grpc/src/test/java/org/apache/ratis/grpc/MiniRaftClusterWithGRpc.java
@@ -0,0 +1,144 @@
+/**
+ * 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.ratis.grpc;
+
+import com.google.common.base.Preconditions;
+
+import org.apache.ratis.MiniRaftCluster;
+import org.apache.ratis.RaftTestUtil;
+import org.apache.ratis.client.RaftClientRequestSender;
+import org.apache.ratis.conf.RaftProperties;
+import org.apache.ratis.grpc.RaftGRpcService;
+import org.apache.ratis.grpc.RaftGrpcConfigKeys;
+import org.apache.ratis.grpc.client.RaftClientSenderWithGrpc;
+import org.apache.ratis.grpc.server.PipelinedLogAppenderFactory;
+import org.apache.ratis.protocol.RaftPeer;
+import org.apache.ratis.server.impl.BlockRequestHandlingInjection;
+import org.apache.ratis.server.impl.DelayLocalExecutionInjection;
+import org.apache.ratis.server.impl.LogAppenderFactory;
+import org.apache.ratis.server.impl.RaftServerImpl;
+import org.apache.ratis.util.NetUtils;
+
+import static org.apache.ratis.server.RaftServerConfigKeys.RAFT_SERVER_LOG_APPENDER_FACTORY_CLASS_KEY;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+public class MiniRaftClusterWithGRpc extends MiniRaftCluster.RpcBase {
+ public static final Factory FACTORY
+ = new Factory() {
+ @Override
+ public MiniRaftClusterWithGRpc newCluster(
+ String[] ids, RaftProperties prop, boolean formatted) throws IOException {
+ return new MiniRaftClusterWithGRpc(ids, prop, formatted);
+ }
+ };
+
+ public static final DelayLocalExecutionInjection sendServerRequestInjection =
+ new DelayLocalExecutionInjection(RaftGRpcService.GRPC_SEND_SERVER_REQUEST);
+
+ public MiniRaftClusterWithGRpc(int numServers, RaftProperties properties)
+ throws IOException {
+ this(generateIds(numServers, 0), properties, true);
+ }
+
+ public MiniRaftClusterWithGRpc(String[] ids, RaftProperties properties,
+ boolean formatted) throws IOException {
+ super(ids, getPropForGrpc(properties), formatted);
+ init(initRpcServices(getServers(), properties));
+ }
+
+ private static RaftProperties getPropForGrpc(RaftProperties prop) {
+ RaftProperties newProp = new RaftProperties(prop);
+ newProp.setClass(RAFT_SERVER_LOG_APPENDER_FACTORY_CLASS_KEY,
+ PipelinedLogAppenderFactory.class, LogAppenderFactory.class);
+ return newProp;
+ }
+
+ private static Map initRpcServices(
+ Collection servers, RaftProperties prop) throws IOException {
+ final Map peerRpcs = new HashMap<>();
+
+ for (RaftServerImpl s : servers) {
+ final RaftGRpcService rpc = RaftGRpcService.newBuilder()
+ .setFromRaftProperties(prop)
+ .setServer(s)
+ .build();
+ peerRpcs.put(new RaftPeer(s.getId(), rpc.getInetSocketAddress()), rpc);
+ }
+ return peerRpcs;
+ }
+
+ @Override
+ public RaftClientRequestSender getRaftClientRequestSender() {
+ return new RaftClientSenderWithGrpc(getPeers());
+ }
+
+ @Override
+ protected Collection addNewPeers(Collection