diff --git a/.classpath b/.classpath
index 5ee3f97..058b340 100644
--- a/.classpath
+++ b/.classpath
@@ -2,7 +2,6 @@
<classpath>
<classpathentry kind="src" path="src/java"/>
<classpathentry kind="src" path="build/java"/>
- <classpathentry kind="src" path="src/java-unsafe"/>
<classpathentry kind="src" path="src/test-resources"/>
<classpathentry kind="src" path="build/jni"/>
<classpathentry kind="src" path="src/test"/>
diff --git a/CHANGES.md b/CHANGES.md
index c7eed89..b71dc35 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -140,12 +140,6 @@
- [#99](https://github.com/lz4/lz4-java/pull/99)
LZ4FrameInputStream allows EndMark to be incompressible. (Charles Allen)
- - [#95](https://github.com/lz4/lz4-java/pull/95)
- Added unsafe instance support for aarch64. (Yuqi Gu)
-
- - [#93](https://github.com/lz4/lz4-java/pull/93)
- Added unsafe instance support for ppc64le. (Madhusudanan Kandasamy)
-
- [#90](https://github.com/lz4/lz4-java/issues/90)
LZ4 Java now supports 64-bit JNI build on Solaris. (cndcourt)
@@ -207,11 +201,6 @@
- [#39](https://github.com/jpountz/lz4-java/pull/39)
The JAR is now a valid OSGI bundle. (Simon Chemouil)
- - [#33](https://github.com/jpountz/lz4-java/pull/33)
- The implementation based on Java's sun.misc.Unsafe relies on unaligned
- memory access and is now only used on platforms that support it.
- (Dmitry Shohov)
-
## 1.2.0
diff --git a/README.md b/README.md
index 9a34ea6..b966d9a 100644
--- a/README.md
+++ b/README.md
@@ -24,12 +24,10 @@ decompressor instance.
## Implementations
-For LZ4 compressors, LZ4 HC compressors and decompressors, 3 implementations are
+For LZ4 compressors, LZ4 HC compressors and decompressors, 2 implementations are
available:
- JNI bindings to the original C implementation by Yann Collet,
- a pure Java port of the compression and decompression algorithms,
- - a Java port that uses the sun.misc.Unsafe API in order to achieve compression
- and decompression speeds close to the C implementation.
Have a look at LZ4Factory for more information.
@@ -94,8 +92,7 @@ score of 10) hash function.
## Implementations
-Similarly to LZ4, 3 implementations are available: JNI bindings, pure Java port
-and pure Java port that uses sun.misc.Unsafe.
+Unsimilarly to LZ4, 2 implementations are available: JNI bindings, pure Java port
Have a look at XXHashFactory for more information.
@@ -131,7 +128,7 @@ int hash = hash32.getValue();
You can download released artifacts from [Maven Central](https://search.maven.org/search?q=g:org.lz4%20a:lz4-java).
-You can download pure-Java lz4-java from [Maven Central](https://search.maven.org/search?q=g:org.lz4%20a:lz4-pure-java). These artifacts include the Safe and Unsafe Java versions but not JNI bindings. (Experimental)
+You can download pure-Java lz4-java from [Maven Central](https://search.maven.org/search?q=g:org.lz4%20a:lz4-pure-java). These artifacts include the Safe Java versions but not JNI bindings. (Experimental)
# Documentation
@@ -172,10 +169,8 @@ Then run `ant`. It will:
located under `src/build`,
- compile the lz4 and xxhash libraries and their JNI (Java Native Interface)
bindings,
- - compile Java sources in `src/java` (normal sources), `src/java-unsafe`
- (sources that make use of `sun.misc.Unsafe`) and `build/java`
- (auto-generated sources) to `build/classes`, `build/unsafe-classes` and
- `build/generated-classes`,
+ - compile Java sources in `src/java` (normal sources) and `build/java`
+ (auto-generated sources) to `build/classes` and `build/generated-classes`,
- generate a JAR file called lz4-${version}.jar under the `dist` directory.
The JAR file that is generated contains Java class files, the native library
diff --git a/build.xml b/build.xml
index 2a08ad8..1d4cff5 100644
--- a/build.xml
+++ b/build.xml
@@ -148,16 +148,6 @@
debug="true"
destdir="${build}/classes"
nativeHeaderDir="${build}/jni-headers"/>
- <mkdir dir="${build}/unsafe-classes" />
- <javac
- includeAntRuntime="false"
- srcdir="${src}/java-unsafe"
- source="${javac.source}"
- target="${javac.target}"
- encoding="UTF-8"
- debug="true"
- classpath="${build}/classes"
- destdir="${build}/unsafe-classes"/>
<mkdir dir="${build}/generated-classes" />
<javac
includeAntRuntime="false"
@@ -169,7 +159,6 @@
destdir="${build}/generated-classes">
<classpath>
<pathelement location="${build}/classes/" />
- <pathelement location="${build}/unsafe-classes" />
</classpath>
</javac>
</target>
@@ -234,7 +223,6 @@
<path id="compile.tests.classpath">
<pathelement path="${build}/classes" />
- <pathelement path="${build}/unsafe-classes" />
<pathelement path="${build}/generated-classes" />
<fileset dir="lib" includes="*.jar" />
</path>
@@ -249,7 +237,6 @@
<pathelement path="${src}/resources" />
<pathelement path="${src}/test-resources" />
<pathelement path="${build}/classes" />
- <pathelement path="${build}/unsafe-classes" />
<pathelement path="${build}/generated-classes" />
<pathelement path="${build}/test-classes" />
<fileset dir="${lib}" includes="*.jar" />
@@ -317,7 +304,6 @@
<jar
destfile="${dist}/${ivy.module}-${ivy.revision}-sources.jar">
<fileset dir="${src}/java" />
- <fileset dir="${src}/java-unsafe" />
</jar>
</target>
@@ -351,7 +337,6 @@
destfile="${dist}/${ivy.module}.jar">
<fileset dir="${src}/resources" erroronmissingdir="false" />
<fileset dir="${build}/classes" />
- <fileset dir="${build}/unsafe-classes" />
<fileset dir="${build}/generated-classes" />
<fileset dir="${build}/jni" erroronmissingdir="false" />
<manifest>
@@ -365,7 +350,6 @@
<jar
destfile="${dist}/${ivy.module}.jar">
<fileset dir="${build}/classes" />
- <fileset dir="${build}/unsafe-classes" />
<fileset dir="${build}/generated-classes" />
<manifest>
<attribute name="Automatic-Module-Name" value="org.lz4.pure.java"/>
@@ -411,15 +395,12 @@
<target name="forbidden-apis" description="check API usage" depends="install-forbidden-apis,compile">
<forbidden-apis internalRuntimeForbidden="true" classpathref="forbidden-apis.classpath">
- <bundledSignatures name="jdk-unsafe-${javac.target}"/>
<bundledSignatures name="jdk-deprecated-${javac.target}"/>
<fileset dir="${build}/classes" includes="**/*.class" />
</forbidden-apis>
<forbidden-apis classpathref="forbidden-apis.classpath">
- <bundledSignatures name="jdk-unsafe-${javac.target}"/>
<bundledSignatures name="jdk-deprecated-${javac.target}"/>
<fileset dir="${build}/classes" includes="**/*.class" />
- <fileset dir="${build}/unsafe-classes" includes="**/*.class" />
</forbidden-apis>
</target>
diff --git a/src/build/gen_sources.mvel b/src/build/gen_sources.mvel
index 0f32671..43ebb78 100644
--- a/src/build/gen_sources.mvel
+++ b/src/build/gen_sources.mvel
@@ -24,7 +24,7 @@ def dest_file(path) {
def generate_decompressors() {
compiledTemplate = get_template("decompressor.template");
- for (type : ["Safe", "Unsafe"]) {
+ for (type : ["Safe"]) {
for (size : ["Fast", "Safe"]) {
dest = dest_file("lz4/LZ4Java" + type + size + "Decompressor.java");
args = new HashMap();
@@ -37,7 +37,7 @@ def generate_decompressors() {
def generate_compressors() {
compiledTemplate = get_template("compressor.template");
- for (type : ["Safe", "Unsafe"]) {
+ for (type : ["Safe"]) {
dest = dest_file("lz4/LZ4Java" + type + "Compressor.java");
args = new HashMap();
args.put("type", type);
@@ -47,7 +47,7 @@ def generate_compressors() {
def generate_hc_compressors() {
compiledTemplate = get_template("compressor_hc.template");
- for (type : ["Safe", "Unsafe"]) {
+ for (type : ["Safe"]) {
dest = dest_file("lz4/LZ4HCJava" + type + "Compressor.java");
args = new HashMap();
args.put("type", type);
@@ -58,7 +58,7 @@ def generate_hc_compressors() {
def generate_xxhash() {
for (bitness : ["32", "64"]) {
compiledTemplate = get_template("xxhash" + bitness + ".template");
- for (type : ["Safe", "Unsafe"]) {
+ for (type : ["Safe"]) {
dest = dest_file("xxhash/XXHash" + bitness + "Java" + type + ".java");
args = new HashMap();
args.put("type", type);
@@ -70,7 +70,7 @@ def generate_xxhash() {
def generate_streaming_xxhash() {
for (bitness : ["32", "64"]) {
compiledTemplate = get_template("xxhash" + bitness + "_streaming.template");
- for (type : ["Safe", "Unsafe"]) {
+ for (type : ["Safe"]) {
dest = dest_file("xxhash/StreamingXXHash" + bitness + "Java" + type + ".java");
args = new HashMap();
args.put("type", type);
diff --git a/src/java-unsafe/net/jpountz/lz4/LZ4UnsafeUtils.java b/src/java-unsafe/net/jpountz/lz4/LZ4UnsafeUtils.java
deleted file mode 100644
index a5ad783..0000000
--- a/src/java-unsafe/net/jpountz/lz4/LZ4UnsafeUtils.java
+++ /dev/null
@@ -1,206 +0,0 @@
-package net.jpountz.lz4;
-
-/*
- * 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.
- */
-
-import static net.jpountz.lz4.LZ4Constants.COPY_LENGTH;
-import static net.jpountz.lz4.LZ4Constants.LAST_LITERALS;
-import static net.jpountz.lz4.LZ4Constants.ML_BITS;
-import static net.jpountz.lz4.LZ4Constants.ML_MASK;
-import static net.jpountz.lz4.LZ4Constants.RUN_MASK;
-import static net.jpountz.util.UnsafeUtils.readByte;
-import static net.jpountz.util.UnsafeUtils.readInt;
-import static net.jpountz.util.UnsafeUtils.readLong;
-import static net.jpountz.util.UnsafeUtils.readShort;
-import static net.jpountz.util.UnsafeUtils.writeByte;
-import static net.jpountz.util.UnsafeUtils.writeInt;
-import static net.jpountz.util.UnsafeUtils.writeLong;
-import static net.jpountz.util.UnsafeUtils.writeShort;
-import static net.jpountz.util.Utils.NATIVE_BYTE_ORDER;
-
-import java.nio.ByteOrder;
-
-enum LZ4UnsafeUtils {
- ;
-
- static void safeArraycopy(byte[] src, int srcOff, byte[] dest, int destOff, int len) {
- final int fastLen = len & 0xFFFFFFF8;
- wildArraycopy(src, srcOff, dest, destOff, fastLen);
- for (int i = 0, slowLen = len & 0x7; i < slowLen; i += 1) {
- writeByte(dest, destOff + fastLen + i, readByte(src, srcOff + fastLen + i));
- }
- }
-
- static void wildArraycopy(byte[] src, int srcOff, byte[] dest, int destOff, int len) {
- for (int i = 0; i < len; i += 8) {
- writeLong(dest, destOff + i, readLong(src, srcOff + i));
- }
- }
-
- static void wildIncrementalCopy(byte[] dest, int matchOff, int dOff, int matchCopyEnd) {
- if (dOff - matchOff < 4) {
- for (int i = 0; i < 4; ++i) {
- writeByte(dest, dOff+i, readByte(dest, matchOff+i));
- }
- dOff += 4;
- matchOff += 4;
- int dec = 0;
- assert dOff >= matchOff && dOff - matchOff < 8;
- switch (dOff - matchOff) {
- case 1:
- matchOff -= 3;
- break;
- case 2:
- matchOff -= 2;
- break;
- case 3:
- matchOff -= 3;
- dec = -1;
- break;
- case 5:
- dec = 1;
- break;
- case 6:
- dec = 2;
- break;
- case 7:
- dec = 3;
- break;
- default:
- break;
- }
- writeInt(dest, dOff, readInt(dest, matchOff));
- dOff += 4;
- matchOff -= dec;
- } else if (dOff - matchOff < COPY_LENGTH) {
- writeLong(dest, dOff, readLong(dest, matchOff));
- dOff += dOff - matchOff;
- }
- while (dOff < matchCopyEnd) {
- writeLong(dest, dOff, readLong(dest, matchOff));
- dOff += 8;
- matchOff += 8;
- }
- }
-
- static void safeIncrementalCopy(byte[] dest, int matchOff, int dOff, int matchLen) {
- for (int i = 0; i < matchLen; ++i) {
- dest[dOff + i] = dest[matchOff + i];
- writeByte(dest, dOff + i, readByte(dest, matchOff + i));
- }
- }
-
- static int readShortLittleEndian(byte[] src, int srcOff) {
- short s = readShort(src, srcOff);
- if (NATIVE_BYTE_ORDER == ByteOrder.BIG_ENDIAN) {
- s = Short.reverseBytes(s);
- }
- return s & 0xFFFF;
- }
-
- static void writeShortLittleEndian(byte[] dest, int destOff, int value) {
- short s = (short) value;
- if (NATIVE_BYTE_ORDER == ByteOrder.BIG_ENDIAN) {
- s = Short.reverseBytes(s);
- }
- writeShort(dest, destOff, s);
- }
-
- static boolean readIntEquals(byte[] src, int ref, int sOff) {
- return readInt(src, ref) == readInt(src, sOff);
- }
-
- static int commonBytes(byte[] src, int ref, int sOff, int srcLimit) {
- int matchLen = 0;
- while (sOff <= srcLimit - 8) {
- if (readLong(src, sOff) == readLong(src, ref)) {
- matchLen += 8;
- ref += 8;
- sOff += 8;
- } else {
- final int zeroBits;
- if (NATIVE_BYTE_ORDER == ByteOrder.BIG_ENDIAN) {
- zeroBits = Long.numberOfLeadingZeros(readLong(src, sOff) ^ readLong(src, ref));
- } else {
- zeroBits = Long.numberOfTrailingZeros(readLong(src, sOff) ^ readLong(src, ref));
- }
- return matchLen + (zeroBits >>> 3);
- }
- }
- while (sOff < srcLimit && readByte(src, ref++) == readByte(src, sOff++)) {
- ++matchLen;
- }
- return matchLen;
- }
-
- static int writeLen(int len, byte[] dest, int dOff) {
- while (len >= 0xFF) {
- writeByte(dest, dOff++, 0xFF);
- len -= 0xFF;
- }
- writeByte(dest, dOff++, len);
- return dOff;
- }
-
- static int encodeSequence(byte[] src, int anchor, int matchOff, int matchRef, int matchLen, byte[] dest, int dOff, int destEnd) {
- final int runLen = matchOff - anchor;
- final int tokenOff = dOff++;
- int token;
-
- if (runLen >= RUN_MASK) {
- token = (byte) (RUN_MASK << ML_BITS);
- dOff = writeLen(runLen - RUN_MASK, dest, dOff);
- } else {
- token = runLen << ML_BITS;
- }
-
- // copy literals
- wildArraycopy(src, anchor, dest, dOff, runLen);
- dOff += runLen;
-
- // encode offset
- final int matchDec = matchOff - matchRef;
- dest[dOff++] = (byte) matchDec;
- dest[dOff++] = (byte) (matchDec >>> 8);
-
- // encode match len
- matchLen -= 4;
- if (dOff + (1 + LAST_LITERALS) + (matchLen >>> 8) > destEnd) {
- throw new LZ4Exception("maxDestLen is too small");
- }
- if (matchLen >= ML_MASK) {
- token |= ML_MASK;
- dOff = writeLen(matchLen - RUN_MASK, dest, dOff);
- } else {
- token |= matchLen;
- }
-
- dest[tokenOff] = (byte) token;
-
- return dOff;
- }
-
- static int commonBytesBackward(byte[] b, int o1, int o2, int l1, int l2) {
- int count = 0;
- while (o1 > l1 && o2 > l2 && readByte(b, --o1) == readByte(b, --o2)) {
- ++count;
- }
- return count;
- }
-
- static int lastLiterals(byte[] src, int sOff, int srcLen, byte[] dest, int dOff, int destEnd) {
- return LZ4SafeUtils.lastLiterals(src, sOff, srcLen, dest, dOff, destEnd);
- }
-
-}
diff --git a/src/java-unsafe/net/jpountz/util/UnsafeUtils.java b/src/java-unsafe/net/jpountz/util/UnsafeUtils.java
deleted file mode 100644
index 30231ef..0000000
--- a/src/java-unsafe/net/jpountz/util/UnsafeUtils.java
+++ /dev/null
@@ -1,147 +0,0 @@
-package net.jpountz.util;
-
-/*
- * 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.
- */
-
-import static net.jpountz.util.Utils.NATIVE_BYTE_ORDER;
-
-import java.lang.reflect.Field;
-import java.nio.ByteOrder;
-
-import sun.misc.Unsafe;
-
-public enum UnsafeUtils {
- ;
-
- private static final Unsafe UNSAFE;
- private static final long BYTE_ARRAY_OFFSET;
- private static final int BYTE_ARRAY_SCALE;
- private static final long INT_ARRAY_OFFSET;
- private static final int INT_ARRAY_SCALE;
- private static final long SHORT_ARRAY_OFFSET;
- private static final int SHORT_ARRAY_SCALE;
-
- static {
- try {
- Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
- theUnsafe.setAccessible(true);
- UNSAFE = (Unsafe) theUnsafe.get(null);
- BYTE_ARRAY_OFFSET = UNSAFE.arrayBaseOffset(byte[].class);
- BYTE_ARRAY_SCALE = UNSAFE.arrayIndexScale(byte[].class);
- INT_ARRAY_OFFSET = UNSAFE.arrayBaseOffset(int[].class);
- INT_ARRAY_SCALE = UNSAFE.arrayIndexScale(int[].class);
- SHORT_ARRAY_OFFSET = UNSAFE.arrayBaseOffset(short[].class);
- SHORT_ARRAY_SCALE = UNSAFE.arrayIndexScale(short[].class);
- } catch (IllegalAccessException e) {
- throw new ExceptionInInitializerError("Cannot access Unsafe");
- } catch (NoSuchFieldException e) {
- throw new ExceptionInInitializerError("Cannot access Unsafe");
- } catch (SecurityException e) {
- throw new ExceptionInInitializerError("Cannot access Unsafe");
- }
- }
-
- public static void checkRange(byte[] buf, int off) {
- SafeUtils.checkRange(buf, off);
- }
-
- public static void checkRange(byte[] buf, int off, int len) {
- SafeUtils.checkRange(buf, off, len);
- }
-
- public static void checkLength(int len) {
- SafeUtils.checkLength(len);
- }
-
- public static byte readByte(byte[] src, int srcOff) {
- return UNSAFE.getByte(src, BYTE_ARRAY_OFFSET + BYTE_ARRAY_SCALE * srcOff);
- }
-
- public static void writeByte(byte[] src, int srcOff, byte value) {
- UNSAFE.putByte(src, BYTE_ARRAY_OFFSET + BYTE_ARRAY_SCALE * srcOff, (byte) value);
- }
-
- public static void writeByte(byte[] src, int srcOff, int value) {
- writeByte(src, srcOff, (byte) value);
- }
-
- public static long readLong(byte[] src, int srcOff) {
- return UNSAFE.getLong(src, BYTE_ARRAY_OFFSET + srcOff);
- }
-
- public static long readLongLE(byte[] src, int srcOff) {
- long i = readLong(src, srcOff);
- if (NATIVE_BYTE_ORDER == ByteOrder.BIG_ENDIAN) {
- i = Long.reverseBytes(i);
- }
- return i;
- }
-
- public static void writeLong(byte[] dest, int destOff, long value) {
- UNSAFE.putLong(dest, BYTE_ARRAY_OFFSET + destOff, value);
- }
-
- public static int readInt(byte[] src, int srcOff) {
- return UNSAFE.getInt(src, BYTE_ARRAY_OFFSET + srcOff);
- }
-
- public static int readIntLE(byte[] src, int srcOff) {
- int i = readInt(src, srcOff);
- if (NATIVE_BYTE_ORDER == ByteOrder.BIG_ENDIAN) {
- i = Integer.reverseBytes(i);
- }
- return i;
- }
-
- public static void writeInt(byte[] dest, int destOff, int value) {
- UNSAFE.putInt(dest, BYTE_ARRAY_OFFSET + destOff, value);
- }
-
- public static short readShort(byte[] src, int srcOff) {
- return UNSAFE.getShort(src, BYTE_ARRAY_OFFSET + srcOff);
- }
-
- public static int readShortLE(byte[] src, int srcOff) {
- short s = readShort(src, srcOff);
- if (NATIVE_BYTE_ORDER == ByteOrder.BIG_ENDIAN) {
- s = Short.reverseBytes(s);
- }
- return s & 0xFFFF;
- }
-
- public static void writeShort(byte[] dest, int destOff, short value) {
- UNSAFE.putShort(dest, BYTE_ARRAY_OFFSET + destOff, value);
- }
-
- public static void writeShortLE(byte[] buf, int off, int v) {
- writeByte(buf, off, (byte) v);
- writeByte(buf, off + 1, (byte) (v >>> 8));
- }
-
- public static int readInt(int[] src, int srcOff) {
- return UNSAFE.getInt(src, INT_ARRAY_OFFSET + INT_ARRAY_SCALE * srcOff);
- }
-
- public static void writeInt(int[] dest, int destOff, int value) {
- UNSAFE.putInt(dest, INT_ARRAY_OFFSET + INT_ARRAY_SCALE * destOff, value);
- }
-
- public static int readShort(short[] src, int srcOff) {
- return UNSAFE.getShort(src, SHORT_ARRAY_OFFSET + SHORT_ARRAY_SCALE * srcOff) & 0xFFFF;
- }
-
- public static void writeShort(short[] dest, int destOff, int value) {
- UNSAFE.putShort(dest, SHORT_ARRAY_OFFSET + SHORT_ARRAY_SCALE * destOff, (short) value);
- }
-}
diff --git a/src/java/net/jpountz/lz4/LZ4Factory.java b/src/java/net/jpountz/lz4/LZ4Factory.java
index e04867b..69f81fa 100644
--- a/src/java/net/jpountz/lz4/LZ4Factory.java
+++ b/src/java/net/jpountz/lz4/LZ4Factory.java
@@ -32,8 +32,6 @@ import static net.jpountz.lz4.LZ4Constants.MAX_COMPRESSION_LEVEL;
* <a href="https://github.com/lz4/lz4">the original LZ4 C implementation</a>.
* <li>a {@link #safeInstance() safe Java} instance which is a pure Java port
* of the original C library,</li>
- * <li>an {@link #unsafeInstance() unsafe Java} instance which is a Java port
- * using the unofficial {@link sun.misc.Unsafe} API.
* </ul>
* <p>
* Only the {@link #safeInstance() safe instance} is guaranteed to work on your
@@ -55,7 +53,6 @@ public final class LZ4Factory {
}
private static LZ4Factory NATIVE_INSTANCE,
- JAVA_UNSAFE_INSTANCE,
JAVA_SAFE_INSTANCE;
/**
@@ -107,42 +104,15 @@ public final class LZ4Factory {
return JAVA_SAFE_INSTANCE;
}
- /**
- * Returns a {@link LZ4Factory} instance that returns compressors and
- * decompressors that may use {@link sun.misc.Unsafe} to speed up compression
- * and decompression.
- *
- * @return a {@link LZ4Factory} instance that returns compressors and
- * decompressors that may use {@link sun.misc.Unsafe} to speed up compression
- * and decompression.
- */
- public static synchronized LZ4Factory unsafeInstance() {
- if (JAVA_UNSAFE_INSTANCE == null) {
- JAVA_UNSAFE_INSTANCE = instance("JavaUnsafe");
- }
- return JAVA_UNSAFE_INSTANCE;
- }
-
/**
* Returns the fastest available {@link LZ4Factory} instance which does not
- * rely on JNI bindings. It first tries to load the
- * {@link #unsafeInstance() unsafe instance}, and then the
- * {@link #safeInstance() safe Java instance} if the JVM doesn't have a
- * working {@link sun.misc.Unsafe}.
+ * rely on JNI bindings. It loads {@link #safeInstance() safe Java instance}
*
* @return the fastest available {@link LZ4Factory} instance which does not
* rely on JNI bindings.
*/
public static LZ4Factory fastestJavaInstance() {
- if (Utils.isUnalignedAccessAllowed()) {
- try {
- return unsafeInstance();
- } catch (Throwable t) {
- return safeInstance();
- }
- } else {
return safeInstance();
- }
}
/**
@@ -249,9 +219,9 @@ public final class LZ4Factory {
* <li>A compression level lower than 1 would be treated as 9.</li>
* </ol>
* Note that compression levels from different implementations
- * (native, unsafe Java, and safe Java) cannot be compared with one another.
+ * (native, and safe Java) cannot be compared with one another.
* Specifically, the native implementation of a high compression level
- * is not necessarily faster than the safe/unsafe Java implementation
+ * is not necessarily faster than the safe Java implementation
* of the same compression level.
*
* @param compressionLevel the compression level between [1, 17]; the higher the level, the higher the compression ratio
diff --git a/src/java/net/jpountz/xxhash/XXHashFactory.java b/src/java/net/jpountz/xxhash/XXHashFactory.java
index 9a9b4d1..9ccdf76 100644
--- a/src/java/net/jpountz/xxhash/XXHashFactory.java
+++ b/src/java/net/jpountz/xxhash/XXHashFactory.java
@@ -28,8 +28,6 @@ import net.jpountz.util.Utils;
* <a href="http://code.google.com/p/xxhash/">the original LZ4 C implementation</a>.
* <li>a {@link #safeInstance() safe Java} instance which is a pure Java port
* of the original C library,</li>
- * <li>an {@link #unsafeInstance() unsafe Java} instance which is a Java port
- * using the unofficial {@link sun.misc.Unsafe} API.
* </ul>
* <p>
* Only the {@link #safeInstance() safe instance} is guaranteed to work on your
@@ -51,7 +49,6 @@ public final class XXHashFactory {
}
private static XXHashFactory NATIVE_INSTANCE,
- JAVA_UNSAFE_INSTANCE,
JAVA_SAFE_INSTANCE;
/**
@@ -96,40 +93,15 @@ public final class XXHashFactory {
return JAVA_SAFE_INSTANCE;
}
- /**
- * Returns a {@link XXHashFactory} that returns {@link XXHash32} instances that
- * may use {@link sun.misc.Unsafe} to speed up hashing.
- *
- * @return a {@link XXHashFactory} that returns {@link XXHash32} instances that
- * may use {@link sun.misc.Unsafe} to speed up hashing.
- */
- public static synchronized XXHashFactory unsafeInstance() {
- if (JAVA_UNSAFE_INSTANCE == null) {
- JAVA_UNSAFE_INSTANCE = instance("JavaUnsafe");
- }
- return JAVA_UNSAFE_INSTANCE;
- }
-
/**
* Returns the fastest available {@link XXHashFactory} instance which does not
- * rely on JNI bindings. It first tries to load the
- * {@link #unsafeInstance() unsafe instance}, and then the
- * {@link #safeInstance() safe Java instance} if the JVM doesn't have a
- * working {@link sun.misc.Unsafe}.
+ * rely on JNI bindings. It loads {@link #safeInstance() safe instance}
*
* @return the fastest available {@link XXHashFactory} instance which does not
* rely on JNI bindings.
*/
public static XXHashFactory fastestJavaInstance() {
- if (Utils.isUnalignedAccessAllowed()) {
- try {
- return unsafeInstance();
- } catch (Throwable t) {
- return safeInstance();
- }
- } else {
return safeInstance();
- }
}
/**
diff --git a/src/test/net/jpountz/lz4/Instances.java b/src/test/net/jpountz/lz4/Instances.java
index b9caae5..44f7809 100644
--- a/src/test/net/jpountz/lz4/Instances.java
+++ b/src/test/net/jpountz/lz4/Instances.java
@@ -21,21 +21,17 @@ enum Instances {
static LZ4Compressor[] COMPRESSORS = new LZ4Compressor[] {
LZ4Factory.nativeInstance().fastCompressor(),
LZ4Factory.nativeInstance().highCompressor(),
- LZ4Factory.unsafeInstance().fastCompressor(),
- LZ4Factory.unsafeInstance().highCompressor(),
LZ4Factory.safeInstance().fastCompressor(),
LZ4Factory.safeInstance().highCompressor()
};
static LZ4FastDecompressor[] FAST_DECOMPRESSORS = new LZ4FastDecompressor[] {
LZ4Factory.nativeInstance().fastDecompressor(),
- LZ4Factory.unsafeInstance().fastDecompressor(),
LZ4Factory.safeInstance().fastDecompressor()
};
static LZ4SafeDecompressor[] SAFE_DECOMPRESSORS = new LZ4SafeDecompressor[] {
LZ4Factory.nativeInstance().safeDecompressor(),
- LZ4Factory.unsafeInstance().safeDecompressor(),
LZ4Factory.safeInstance().safeDecompressor()
};
diff --git a/src/test/net/jpountz/lz4/LZ4FactoryTest.java b/src/test/net/jpountz/lz4/LZ4FactoryTest.java
index c4ef05e..b8b33d7 100644
--- a/src/test/net/jpountz/lz4/LZ4FactoryTest.java
+++ b/src/test/net/jpountz/lz4/LZ4FactoryTest.java
@@ -21,17 +21,13 @@ public class LZ4FactoryTest extends TestCase {
public void test() {
assertEquals(LZ4JNICompressor.INSTANCE, LZ4Factory.nativeInstance().fastCompressor());
assertEquals(LZ4HCJNICompressor.INSTANCE, LZ4Factory.nativeInstance().highCompressor());
- assertEquals(LZ4JavaUnsafeCompressor.INSTANCE, LZ4Factory.unsafeInstance().fastCompressor());
- assertEquals(LZ4HCJavaUnsafeCompressor.INSTANCE, LZ4Factory.unsafeInstance().highCompressor());
assertEquals(LZ4JavaSafeCompressor.INSTANCE, LZ4Factory.safeInstance().fastCompressor());
assertEquals(LZ4HCJavaSafeCompressor.INSTANCE, LZ4Factory.safeInstance().highCompressor());
assertEquals(LZ4JNIFastDecompressor.INSTANCE, LZ4Factory.nativeInstance().fastDecompressor());
- assertEquals(LZ4JavaUnsafeFastDecompressor.INSTANCE, LZ4Factory.unsafeInstance().fastDecompressor());
assertEquals(LZ4JavaSafeFastDecompressor.INSTANCE, LZ4Factory.safeInstance().fastDecompressor());
assertEquals(LZ4JNISafeDecompressor.INSTANCE, LZ4Factory.nativeInstance().safeDecompressor());
- assertEquals(LZ4JavaUnsafeSafeDecompressor.INSTANCE, LZ4Factory.unsafeInstance().safeDecompressor());
assertEquals(LZ4JavaSafeSafeDecompressor.INSTANCE, LZ4Factory.safeInstance().safeDecompressor());
}
diff --git a/src/test/net/jpountz/xxhash/XXHashFactoryTest.java b/src/test/net/jpountz/xxhash/XXHashFactoryTest.java
index c410220..2aae562 100644
--- a/src/test/net/jpountz/xxhash/XXHashFactoryTest.java
+++ b/src/test/net/jpountz/xxhash/XXHashFactoryTest.java
@@ -21,14 +21,10 @@ public class XXHashFactoryTest extends TestCase {
public void test() {
assertEquals(XXHash32JNI.INSTANCE, XXHashFactory.nativeInstance().hash32());
assertTrue(XXHashFactory.nativeInstance().newStreamingHash32(0) instanceof StreamingXXHash32JNI);
- assertEquals(XXHash32JavaUnsafe.INSTANCE, XXHashFactory.unsafeInstance().hash32());
- assertTrue(XXHashFactory.unsafeInstance().newStreamingHash32(0) instanceof StreamingXXHash32JavaUnsafe);
assertEquals(XXHash32JavaSafe.INSTANCE, XXHashFactory.safeInstance().hash32());
assertTrue(XXHashFactory.safeInstance().newStreamingHash32(0) instanceof StreamingXXHash32JavaSafe);
assertEquals(XXHash64JNI.INSTANCE, XXHashFactory.nativeInstance().hash64());
assertTrue(XXHashFactory.nativeInstance().newStreamingHash64(0) instanceof StreamingXXHash64JNI);
- assertEquals(XXHash64JavaUnsafe.INSTANCE, XXHashFactory.unsafeInstance().hash64());
- assertTrue(XXHashFactory.unsafeInstance().newStreamingHash64(0) instanceof StreamingXXHash64JavaUnsafe);
assertEquals(XXHash64JavaSafe.INSTANCE, XXHashFactory.safeInstance().hash64());
assertTrue(XXHashFactory.safeInstance().newStreamingHash64(0) instanceof StreamingXXHash64JavaSafe);
}