Improve performance benchmark a bit; add byte[]-taking variant for name-based variant

Author: cowtowncoder

pom.xml

@@ -12,7 +12,7 @@
   <artifactId>java-uuid-generator</artifactId>
   <packaging>bundle</packaging>
   <name>Java UUID Generator</name>
-  <version>3.0.1-SNAPSHOT</version>
+  <version>3.1.0-SNAPSHOT</version>
   <description>
 Java UUID Generator (JUG) is a Java library for generating
 Universally Unique IDentifiers, UUIDs (see http://en.wikipedia.org/wiki/UUID).

src/main/java/com/fasterxml/uuid/StringArgGenerator.java

@@ -10,6 +10,17 @@
  */
 public abstract class StringArgGenerator extends UUIDGenerator
 {
-    public abstract UUID generate(String arg);
+    /**
+     * Method for generating name-based UUIDs using specified name (serialized to
+     * bytes using UTF-8 encoding)
+     */
+    public abstract UUID generate(String name);
 
+    /**
+     * Method for generating name-based UUIDs using specified byte-serialization
+     * of name.
+     * 
+     * @since 3.1
+     */
+    public abstract UUID generate(byte[] nameBytes);
 }

src/main/java/com/fasterxml/uuid/impl/NameBasedGenerator.java

@@ -1,5 +1,6 @@
 package com.fasterxml.uuid.impl;
 
+import java.nio.charset.Charset;
 import java.security.MessageDigest;
 import java.util.UUID;
 
@@ -18,6 +19,11 @@
  */
 public class NameBasedGenerator extends StringArgGenerator
 {
+    public final static Charset _utf8;
+    static {
+        _utf8 = Charset.forName("UTF-8");
+    }
+    
     /**
      * Namespace used when name is a DNS name.
      */
@@ -108,17 +114,24 @@ public NameBasedGenerator(UUID namespace, MessageDigest digester, UUIDType type)
     /* UUID generation
     /**********************************************************************
      */
-    
+
     @Override
     public UUID generate(String name)
+    {
+        // !!! TODO: 14-Oct-2010, tatu: can repurpose faster UTF-8 encoding from Jackson
+        return generate(name.getBytes(_utf8));
+    }
+    
+    @Override
+    public UUID generate(byte[] nameBytes)
     {
         byte[] digest;
         synchronized (_digester) {
             _digester.reset();
             if (_namespace != null) {
                 _digester.update(UUIDUtil.asByteArray(_namespace));
             }
-            _digester.update(name.getBytes());
+            _digester.update(nameBytes);
             digest = _digester.digest();
         }
         return UUIDUtil.constructUUID(_type, digest);

src/main/java/com/fasterxml/uuid/impl/RandomBasedGenerator.java

@@ -43,8 +43,7 @@ public class RandomBasedGenerator extends NoArgGenerator
     public RandomBasedGenerator(Random rnd)
     {
         if (rnd == null) {
-            /*
-             * Could be synchronized, but since side effects are trivial
+            /* Could be synchronized, but since side effects are trivial
              * (ie. possibility of generating more than one SecureRandom,
              * of which all but one are dumped) let's not add synchronization
              * overhead.

src/main/java/test/MeasurePerformance.java

@@ -8,15 +8,31 @@
 /**
  * Simple micro-benchmark for evaluating performance of various UUID generation
  * techniques, including JDK's method as well as JUG's variants.
+ *<p>
+ * Notes: for name-based variant we will pass plain Strings, assuming this is the
+ * most common use case; even though it is possible to also pass raw byte arrays.
+ * JDK and Jug implementations have similar performance so this only changes
+ * relative speeds of name- vs time-based variants.
  *
- * @since 3.0
+ * @since 3.1
  */
 public class MeasurePerformance
 {
     // Let's generate quarter million UUIDs per test
 
     private static final int ROUNDS = 250;
     private static final int COUNT = 1000;
+
+    private final static UUID NAMESPACE = NameBasedGenerator.NAMESPACE_DNS;
+    
+    // also: let's just use a single name for name-based, to avoid extra overhead:
+    final String NAME = "http://www.cowtowncoder.com/blog/blog.html";
+    final byte[] NAME_BYTES;
+
+    public MeasurePerformance() throws java.io.IOException
+    {
+        NAME_BYTES = NAME.getBytes("UTF-8");
+    }
 
     public void test() throws Exception
     {
@@ -27,19 +43,18 @@ public void test() throws Exception
         // can either use bogus address; or local one, no difference perf-wise
         EthernetAddress nic = EthernetAddress.fromInterface();
 
-        UUID namespaceForNamed = NameBasedGenerator.NAMESPACE_DNS;
-        
+        // Whether to include namespace? Depends on whether we compare with JDK (which does not)
+//        UUID namespaceForNamed = NAMESPACE;
+        UUID namespaceForNamed = null;
+
         final NoArgGenerator secureRandomGen = Generators.randomBasedGenerator();
         final NoArgGenerator utilRandomGen = Generators.randomBasedGenerator(new java.util.Random(123));
         final NoArgGenerator timeGen = Generators.timeBasedGenerator(nic);
         final StringArgGenerator nameGen = Generators.nameBasedGenerator(namespaceForNamed);
-
-        // also: let's just use a single name for name-based, to avoid extra overhead:
-        final String NAME = "http://www.cowtowncoder.com/blog/blog.html";
 
         while (true) {
             try {  Thread.sleep(100L); } catch (InterruptedException ie) { }
-            int round = (i++ % 5);
+            int round = (i++ % 6);
 
             long curr = System.currentTimeMillis();
             String msg;
@@ -48,28 +63,33 @@ public void test() throws Exception
             switch (round) {
 
             case 0:
-                msg = "JDK";
+                msg = "JDK, random";
                 testJDK(uuids, ROUNDS);
                 break;
-    
+
             case 1:
+                msg = "JDK, name";
+                testJDKNames(uuids, ROUNDS);
+                break;
+                
+            case 2:
                 msg = "Jug, SecureRandom";
                 testNoArgs(uuids, ROUNDS, secureRandomGen);
                 break;
 
-            case 2:
+            case 3:
                 msg = "Jug, java.util.Random";
                 testNoArgs(uuids, ROUNDS, utilRandomGen);
                 break;
 
-            case 3:
+            case 4:
                 msg = "Jug, time-based";
                 testNoArgs(uuids, ROUNDS, timeGen);
                 break;
 
-            case 4:
+            case 5:
                 msg = "Jug, name-based";
-                testStringArg(uuids, ROUNDS, nameGen, NAME);
+                testStringArg(uuids, ROUNDS, nameGen);
                 break;
 
             default:
@@ -93,6 +113,16 @@ private final void testJDK(UUID[] uuids, int rounds)
         }
     }
 
+    private final void testJDKNames(UUID[] uuids, int rounds) throws java.io.IOException
+    {
+        while (--rounds >= 0) {
+            for (int i = 0, len = uuids.length; i < len; ++i) {
+                final byte[] nameBytes = NAME.getBytes("UTF-8");
+                uuids[i] = UUID.nameUUIDFromBytes(nameBytes);
+            }
+        }
+    }
+    
     private final void testNoArgs(UUID[] uuids, int rounds, NoArgGenerator uuidGen)
     {
         while (--rounds >= 0) {
@@ -102,12 +132,11 @@ private final void testNoArgs(UUID[] uuids, int rounds, NoArgGenerator uuidGen)
         }
     }
 
-    private final void testStringArg(UUID[] uuids, int rounds, StringArgGenerator uuidGen,
-            String name)
+    private final void testStringArg(UUID[] uuids, int rounds, StringArgGenerator uuidGen)
     {
         while (--rounds >= 0) {
             for (int i = 0, len = uuids.length; i < len; ++i) {
-                uuids[i] = uuidGen.generate(name);
+                uuids[i] = uuidGen.generate(NAME);
             }
         }
     }