Add unsafe inflater impl

Author: Col-E

src/main/java/software/coley/llzip/format/compression/UnsafeDeflateDecompressor.java

@@ -0,0 +1,77 @@
+package software.coley.llzip.format.compression;
+
+import software.coley.llzip.format.model.LocalFileHeader;
+import software.coley.llzip.util.BufferData;
+import software.coley.llzip.util.ByteData;
+import software.coley.llzip.util.UnsafeInflater;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.zip.DataFormatException;
+import java.util.zip.ZipException;
+
+/**
+ * Optimized implementation of {@link DeflateDecompressor} with unsafe resetting for more throughput.
+ *
+ * @author xDark
+ */
+public class UnsafeDeflateDecompressor implements Decompressor {
+	private static final Deque<UnsafeInflater> INFLATERS = new ArrayDeque<>();
+
+	@Override
+	public ByteData decompress(LocalFileHeader header, ByteData data) throws IOException {
+		if (header.getCompressionMethod() != ZipCompressions.DEFLATED)
+			throw new IOException("LocalFileHeader contents not using 'Deflated'!");
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		UnsafeInflater inflater;
+		Deque<UnsafeInflater> inflaters = INFLATERS;
+		synchronized (inflaters) {
+			inflater = inflaters.poll();
+			if (inflater == null) {
+				inflater = new UnsafeInflater(true);
+			}
+		}
+		try {
+			byte[] output = new byte[1024];
+			byte[] buffer = new byte[1024];
+			long position = 0L;
+			long length = data.length();
+			do {
+				if (inflater.needsInput()) {
+					int remaining = (int) Math.min(buffer.length, length);
+					if (remaining == 0) {
+						break;
+					}
+					data.get(position, buffer, 0, remaining);
+					length -= remaining;
+					position += remaining;
+					inflater.setInput(buffer, 0, remaining);
+				}
+				int count = inflater.inflate(output);
+				if (count != 0) {
+					out.write(output, 0, count);
+				}
+			} while (!inflater.finished() && !inflater.needsDictionary());
+		} catch (DataFormatException e) {
+			String s = e.getMessage();
+			throw (ZipException) new ZipException(s != null ? null : "Invalid ZLIB data format").initCause(e);
+		} finally {
+			end:
+			{
+				if (inflaters.size() < 32) {
+					synchronized (inflaters) {
+						if (inflaters.size() < 32) {
+							inflater.fastReset();
+							inflaters.push(inflater);
+							break end;
+						}
+					}
+				}
+				inflater.end();
+			}
+		}
+		return BufferData.wrap(out.toByteArray());
+	}
+}

src/main/java/software/coley/llzip/format/compression/ZipCompressions.java

@@ -2,6 +2,7 @@
 
 import software.coley.llzip.format.model.LocalFileHeader;
 import software.coley.llzip.util.ByteData;
+import software.coley.llzip.util.UnsafeInflater;
 
 import java.io.IOException;
 
@@ -208,7 +209,12 @@ static ByteData decompress(LocalFileHeader header) throws IOException {
 			case STORED:
 				return header.getFileData();
 			case DEFLATED:
-				return header.decompress(new DeflateDecompressor());
+				// Use unsafe decompressor if available since it is faster.
+				if (UnsafeInflater.initFail) {
+					return header.decompress(new DeflateDecompressor());
+				} else {
+					return header.decompress(new UnsafeDeflateDecompressor());
+				}
 			default:
 				// TODO: Support other decompressing techniques
 				String methodName = getName(method);

src/main/java/software/coley/llzip/util/UnsafeInflater.java

@@ -0,0 +1,80 @@
+package software.coley.llzip.util;
+
+import sun.misc.Unsafe;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.nio.ByteBuffer;
+import java.util.zip.Inflater;
+
+/**
+ * Inflater extension providing non-synchronized resetting via unsafe.
+ *
+ * @author Matt Coley
+ */
+public class UnsafeInflater extends Inflater {
+	private static final String ERR_SUFFIX = "If this is due to JDK restrictions, use DeflateDecompressor";
+	private static final MethodHandles.Lookup LOOKUP = UnsafeUtil.lookup();
+	private static final Unsafe UNSAFE = UnsafeUtil.get();
+	private static final ByteBuffer DEFAULT_BUF = ByteBuffer.allocate(0);
+	private static long off_zsRef;
+	private static long off_input;
+	private static long off_inputArray;
+	private static long off_finished;
+	private static long off_needDict;
+	private static long off_bytesRead;
+	private static long off_bytesWritten;
+	private static MethodHandle mh_reset;
+	private static MethodHandle mh_address;
+	/** Indicates unsafe init failed */
+	public static boolean initFail;
+
+	static {
+		// All these fields are private, so we will use hacks to access them.
+		try {
+			off_zsRef = UNSAFE.objectFieldOffset(Inflater.class.getDeclaredField("zsRef"));
+			off_input = UNSAFE.objectFieldOffset(Inflater.class.getDeclaredField("input"));
+			off_inputArray = UNSAFE.objectFieldOffset(Inflater.class.getDeclaredField("inputArray"));
+			off_finished = UNSAFE.objectFieldOffset(Inflater.class.getDeclaredField("finished"));
+			off_needDict = UNSAFE.objectFieldOffset(Inflater.class.getDeclaredField("needDict"));
+			off_bytesRead = UNSAFE.objectFieldOffset(Inflater.class.getDeclaredField("bytesRead"));
+			off_bytesWritten = UNSAFE.objectFieldOffset(Inflater.class.getDeclaredField("bytesWritten"));
+			mh_reset = LOOKUP.findStatic(Inflater.class, "reset", MethodType.methodType(void.class, long.class));
+		} catch (Exception ex) {
+			initFail = true;
+		}
+	}
+
+	/**
+	 * @param nowrap
+	 * 		if true then support GZIP compatible compression
+	 */
+	public UnsafeInflater(boolean nowrap) {
+		super(nowrap);
+	}
+
+	/**
+	 * {@link #reset()} but without synchronization.
+	 */
+	public void fastReset() {
+		try {
+			Object zsRefValue = UNSAFE.getObject(this, off_zsRef);
+			if (mh_address == null) {
+				MethodHandles.Lookup lookup = UnsafeUtil.lookup();
+				mh_address = lookup.findGetter(zsRefValue.getClass(), "address", long.class);
+			}
+			long addressRet = (long) mh_address.invoke(zsRefValue);
+			mh_reset.invoke(addressRet);
+			UNSAFE.putObject(this, off_input, DEFAULT_BUF);
+			UNSAFE.putObject(this, off_inputArray, null);
+			UNSAFE.putBoolean(this, off_finished, false);
+			UNSAFE.putBoolean(this, off_needDict, false);
+			UNSAFE.putLong(this, off_bytesRead, 0);
+			UNSAFE.putLong(this, off_bytesWritten, 0);
+		} catch (Throwable ex) {
+			initFail = true;
+			throw new IllegalStateException("Failed to reset unsafely. " + ERR_SUFFIX, ex);
+		}
+	}
+}

src/main/java/software/coley/llzip/util/UnsafeUtil.java

@@ -2,6 +2,7 @@
 
 import sun.misc.Unsafe;
 
+import java.lang.invoke.MethodHandles;
 import java.lang.reflect.Field;
 
 /**
@@ -11,6 +12,7 @@
  */
 class UnsafeUtil {
 	private static final Unsafe UNSAFE;
+	private static final MethodHandles.Lookup LOOKUP;
 
 	/**
 	 * @return Unsafe instance.
@@ -19,11 +21,21 @@ public static Unsafe get() {
 		return UNSAFE;
 	}
 
+	/**
+	 * @return Unsafe instance.
+	 */
+	public static MethodHandles.Lookup lookup() {
+		return LOOKUP;
+	}
+
 	static {
 		try {
 			Field f = Unsafe.class.getDeclaredField("theUnsafe");
 			f.setAccessible(true);
-			UNSAFE = (Unsafe) f.get(null);
+			Unsafe u = UNSAFE = (Unsafe) f.get(null);
+			f = MethodHandles.Lookup.class.getDeclaredField("IMPL_LOOKUP");
+			MethodHandles.publicLookup();
+			LOOKUP = (MethodHandles.Lookup) u.getObject(u.staticFieldBase(f), u.staticFieldOffset(f));
 		} catch (NoSuchFieldException | IllegalAccessException ex) {
 			throw new ExceptionInInitializerError(ex);
 		}