]> gerrit.simantics Code Review - simantics/platform.git/blob - bundles/org.simantics.lz4/src/net/jpountz/xxhash/XXHashFactory.java
Removed redundant Files.exists/isDirectory checks
[simantics/platform.git] / bundles / org.simantics.lz4 / src / net / jpountz / xxhash / XXHashFactory.java
1 package net.jpountz.xxhash;
2
3 /*
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 import java.lang.reflect.Field;
18 import java.util.Random;
19
20 import net.jpountz.util.Native;
21 import net.jpountz.util.Utils;
22
23 /**
24  * Entry point to get {@link XXHash32} and {@link StreamingXXHash32} instances.
25  * <p>
26  * This class has 3 instances<ul>
27  * <li>a {@link #nativeInstance() native} instance which is a JNI binding to
28  * <a href="http://code.google.com/p/xxhash/">the original LZ4 C implementation</a>.
29  * <li>a {@link #safeInstance() safe Java} instance which is a pure Java port
30  * of the original C library,</li>
31  * <li>an {@link #unsafeInstance() unsafe Java} instance which is a Java port
32  * using the unofficial {@link sun.misc.Unsafe} API.
33  * </ul>
34  * <p>
35  * Only the {@link #safeInstance() safe instance} is guaranteed to work on your
36  * JVM, as a consequence it is advised to use the {@link #fastestInstance()} or
37  * {@link #fastestJavaInstance()} to pull a {@link XXHashFactory} instance.
38  * <p>
39  * All methods from this class are very costly, so you should get an instance
40  * once, and then reuse it whenever possible. This is typically done by storing
41  * a {@link XXHashFactory} instance in a static field.
42  */
43 public final class XXHashFactory {
44
45   private static XXHashFactory instance(String impl) {
46     try {
47       return new XXHashFactory(impl);
48     } catch (Exception e) {
49       throw new AssertionError(e);
50     }
51   }
52
53   private static XXHashFactory NATIVE_INSTANCE,
54                                JAVA_UNSAFE_INSTANCE,
55                                JAVA_SAFE_INSTANCE;
56
57   /** Return a {@link XXHashFactory} that returns {@link XXHash32} instances that
58    *  are native bindings to the original C API.
59    * <p>
60    * Please note that this instance has some traps you should be aware of:<ol>
61    * <li>Upon loading this instance, files will be written to the temporary
62    * directory of the system. Although these files are supposed to be deleted
63    * when the JVM exits, they might remain on systems that don't support
64    * removal of files being used such as Windows.
65    * <li>The instance can only be loaded once per JVM. This can be a problem
66    * if your application uses multiple class loaders (such as most servlet
67    * containers): this instance will only be available to the children of the
68    * class loader which has loaded it. As a consequence, it is advised to
69    * either not use this instance in webapps or to put this library in the lib
70    * directory of your servlet container so that it is loaded by the system
71    * class loader.
72    * </ol>
73    */
74   public static synchronized XXHashFactory nativeInstance() {
75     if (NATIVE_INSTANCE == null) {
76       NATIVE_INSTANCE = instance("JNI");
77     }
78     return NATIVE_INSTANCE;
79   }
80
81   /** Return a {@link XXHashFactory} that returns {@link XXHash32} instances that
82    *  are written with Java's official API. */
83   public static synchronized XXHashFactory safeInstance() {
84     if (JAVA_SAFE_INSTANCE == null) {
85       JAVA_SAFE_INSTANCE = instance("JavaSafe");
86     }
87     return JAVA_SAFE_INSTANCE;
88   }
89
90   /** Return a {@link XXHashFactory} that returns {@link XXHash32} instances that
91    *  may use {@link sun.misc.Unsafe} to speed up hashing. */
92   public static synchronized XXHashFactory unsafeInstance() {
93     if (JAVA_UNSAFE_INSTANCE == null) {
94       JAVA_UNSAFE_INSTANCE = instance("JavaUnsafe");
95     }
96     return JAVA_UNSAFE_INSTANCE;
97   }
98
99   /**
100    * Return the fastest available {@link XXHashFactory} instance which does not
101    * rely on JNI bindings. It first tries to load the
102    * {@link #unsafeInstance() unsafe instance}, and then the
103    * {@link #safeInstance() safe Java instance} if the JVM doesn't have a
104    * working {@link sun.misc.Unsafe}.
105    */
106   public static XXHashFactory fastestJavaInstance() {
107     if (Utils.isUnalignedAccessAllowed()) {
108       try {
109         return unsafeInstance();
110       } catch (Throwable t) {
111         return safeInstance();
112       }
113     } else {
114       return safeInstance();
115     }
116   }
117
118   /**
119    * Return the fastest available {@link XXHashFactory} instance. If the class
120    * loader is the system class loader and if the
121    * {@link #nativeInstance() native instance} loads successfully, then the
122    * {@link #nativeInstance() native instance} is returned, otherwise the
123    * {@link #fastestJavaInstance() fastest Java instance} is returned.
124    * <p>
125    * Please read {@link #nativeInstance() javadocs of nativeInstance()} before
126    * using this method.
127    */
128   public static XXHashFactory fastestInstance() {
129     if (!Native.failedToLoad()
130         && (Native.isLoaded()
131             || Native.class.getClassLoader() == ClassLoader.getSystemClassLoader())) {
132       try {
133         return nativeInstance();
134       } catch (Throwable t) {
135         return fastestJavaInstance();
136       }
137     } else {
138       return fastestJavaInstance();
139     }
140   }
141
142   @SuppressWarnings("unchecked")
143   private static <T> T classInstance(String cls) throws NoSuchFieldException, SecurityException, ClassNotFoundException, IllegalArgumentException, IllegalAccessException {
144     ClassLoader loader = XXHashFactory.class.getClassLoader();
145     loader = loader == null ? ClassLoader.getSystemClassLoader() : loader;
146     final Class<?> c = loader.loadClass(cls);
147     Field f = c.getField("INSTANCE");
148     return (T) f.get(null);
149   }
150
151   private final String impl;
152   private final XXHash32 hash32;
153   private final XXHash64 hash64;
154   private final StreamingXXHash32.Factory streamingHash32Factory;
155   private final StreamingXXHash64.Factory streamingHash64Factory;
156
157   private XXHashFactory(String impl) throws ClassNotFoundException, NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
158     this.impl = impl;
159     hash32 = classInstance("net.jpountz.xxhash.XXHash32" + impl);
160     streamingHash32Factory = classInstance("net.jpountz.xxhash.StreamingXXHash32" + impl + "$Factory");
161     hash64 = classInstance("net.jpountz.xxhash.XXHash64" + impl);
162     streamingHash64Factory = classInstance("net.jpountz.xxhash.StreamingXXHash64" + impl + "$Factory");
163
164     // make sure it can run
165     final byte[] bytes = new byte[100];
166     final Random random = new Random();
167     random.nextBytes(bytes);
168     final int seed = random.nextInt();
169
170     final int h1 = hash32.hash(bytes, 0, bytes.length, seed);
171     final StreamingXXHash32 streamingHash32 = newStreamingHash32(seed);
172     streamingHash32.update(bytes, 0, bytes.length);
173     final int h2 = streamingHash32.getValue();
174     final long h3 = hash64.hash(bytes, 0, bytes.length, seed);
175     final StreamingXXHash64 streamingHash64 = newStreamingHash64(seed);
176     streamingHash64.update(bytes, 0, bytes.length);
177     final long h4 = streamingHash64.getValue();
178     if (h1 != h2) {
179       throw new AssertionError();
180     }
181     if (h3 != h4) {
182       throw new AssertionError();
183     }
184   }
185
186   /** Return a {@link XXHash32} instance. */
187   public XXHash32 hash32() {
188     return hash32;
189   }
190
191   /** Return a {@link XXHash64} instance. */
192   public XXHash64 hash64() {
193     return hash64;
194   }
195
196   /**
197    * Return a new {@link StreamingXXHash32} instance.
198    */
199   public StreamingXXHash32 newStreamingHash32(int seed) {
200     return streamingHash32Factory.newStreamingHash(seed);
201   }
202
203   /**
204    * Return a new {@link StreamingXXHash64} instance.
205    */
206   public StreamingXXHash64 newStreamingHash64(long seed) {
207     return streamingHash64Factory.newStreamingHash(seed);
208   }
209
210   /** Prints the fastest instance. */
211   public static void main(String[] args) {
212     System.out.println("Fastest instance is " + fastestInstance());
213     System.out.println("Fastest Java instance is " + fastestJavaInstance());
214   }
215
216   @Override
217   public String toString() {
218     return getClass().getSimpleName() + ":" + impl;
219   }
220
221 }