InputStream test. Updated readme.

Add missing test for reading off InputStream.
Updated DSL-JSON to v1.0
Updated README with latest run.

Author: zapov

README.md

@@ -108,37 +108,43 @@ Results as reported on console, except sorted in descending order of performance
 ```
 % java -Xmx256m -jar target/microbenchmarks.jar ".*DZoneWrite.*write1k.*AsString.*" -wi 4 -i 5 -f 19
 
-# Run complete. Total time: 00:20:58
+# Run complete. Total time: 00:29:51
 
 Benchmark                             Mode  Cnt     Score    Error  Units
-DZoneWriteJackson.write1kAsString    thrpt   95  4377.870 ± 22.375  ops/s
-DZoneWriteJacksonJr.write1kAsString  thrpt   95  3880.734 ± 32.488  ops/s
-DZoneWriteBoon.write1kAsString       thrpt   95  2614.780 ± 15.105  ops/s
-DZoneWriteJohnzon.write1kAsString    thrpt   95  2088.878 ± 12.612  ops/s
-DZoneWriteMoshi.write1kAsString      thrpt   95  1655.735 ±  9.793  ops/s
-DZoneWriteGSON.write1kAsString       thrpt   95  1209.408 ± 10.565  ops/s
-DZoneWriteJsonIO.write1kAsString     thrpt   95   883.185 ±  7.002  ops/s
+DZoneWriteDslJson.write1kAsString    thrpt   95  6222.612 ± 49.992  ops/s
+DZoneWriteFastjson.write1kAsString   thrpt   95  4256.503 ± 21.408  ops/s
+DZoneWriteJacksonAB.write1kAsString  thrpt   95  3898.636 ± 33.145  ops/s
+DZoneWriteJackson.write1kAsString    thrpt   95  3386.443 ± 66.570  ops/s
+DZoneWriteJacksonJr.write1kAsString  thrpt   95  3182.897 ± 29.049  ops/s
+DZoneWriteBoon.write1kAsString       thrpt   95  2300.457 ± 59.546  ops/s
+DZoneWriteJohnzon.write1kAsString    thrpt   95  1528.370 ± 24.255  ops/s
+DZoneWriteMoshi.write1kAsString      thrpt   95  1437.739 ± 22.236  ops/s
+DZoneWriteGSON.write1kAsString       thrpt   95  1057.819 ± 10.063  ops/s
+DZoneWriteJsonIO.write1kAsString     thrpt   95   671.863 ± 14.453  ops/s
 ```
 
-Given that the test measures throughput, Jackson (the fastest) is about 5x as fast as json.io (the slowest) for this test.
+Given that the test measures throughput, DSL-JSON (the fastest) is about 10x as fast as json.io (the slowest) for this test.
 
-#### Reading 1000 item (POJO) list from String
+#### Reading 10 item (POJO) list from String
 
 ```
 % java -Xmx256m -jar target/microbenchmarks.jar ".*DZoneReadPojo.*read10FromString.*" -wi 4 -i 5 -f 9
 
-# Run complete. Total time: 00:10:27
+# Run complete. Total time: 00:13:52
 
 Benchmark                                 Mode  Cnt       Score      Error  Units
-DZoneReadPojoJacksonJr.read10FromString  thrpt   45  217944.421 ± 3606.032  ops/s
-DZoneReadPojoJackson.read10FromString    thrpt   45  215162.661 ± 3699.385  ops/s
-DZoneReadPojoGSON.read10FromString       thrpt   45  143185.788 ± 3431.425  ops/s
-DZoneReadPojoBoon.read10FromString       thrpt   45  118542.144 ± 1747.026  ops/s
-DZoneReadPojoMoshi.read10FromString      thrpt   45   92379.201 ± 1415.529  ops/s
-DZoneReadPojoJohnzon.read10FromString    thrpt   45   74268.988 ± 1505.027  ops/s
+DZoneReadPojoDslJson.read10FromString    thrpt   45  233152.796 ± 2513.390  ops/s
+DZoneReadPojoJacksonAB.read10FromString  thrpt   45  188005.499 ± 5640.662  ops/s
+DZoneReadPojoJacksonJr.read10FromString  thrpt   45  176081.143 ± 3220.812  ops/s
+DZoneReadPojoJackson.read10FromString    thrpt   45  171522.616 ± 1614.882  ops/s
+DZoneReadPojoFastjson.read10FromString   thrpt   45  165517.191 ± 2058.242  ops/s
+DZoneReadPojoGSON.read10FromString       thrpt   45  126607.540 ± 4538.410  ops/s
+DZoneReadPojoBoon.read10FromString       thrpt   45   92211.900 ±  596.884  ops/s
+DZoneReadPojoJohnzon.read10FromString    thrpt   45   70438.271 ±  865.507  ops/s
+DZoneReadPojoMoshi.read10FromString      thrpt   45   73756.350 ±  932.405  ops/s
 ```
 
-And in this case, Jackson is 50% faster than GSON, twice as fast as Moshi and triple Johnzon speed.
+And in this case, DSL-JSON is 20% faster than Jackson which is 50% faster than GSON, twice as fast as Boon and triple Johnzon speed.
 
 Json-io is not (yet) included because it seems to require JSON content to be specifically written by `json-io`
 itself, and not accept standard json representation (probably since it requires type information embedded).
@@ -148,20 +154,67 @@ itself, and not accept standard json representation (probably since it requires
 ```
 % java -Xmx256m -jar target/microbenchmarks.jar ".*DZoneReadMap.*read10FromString.*" -wi 4 -i 5 -f 9
 
-# Run complete. Total time: 00:10:26
+# Run complete. Total time: 00:15:16
 
 Benchmark                                Mode  Cnt       Score      Error  Units
-DZoneReadMapJacksonJr.read10FromString  thrpt   45  233240.208 ± 2844.701  ops/s
-DZoneReadMapBoon.read10FromString       thrpt   45  216714.713 ± 2328.799  ops/s
-DZoneReadMapJackson.read10FromString    thrpt   45  197597.668 ± 2092.722  ops/s
-DZoneReadMapGSON.read10FromString       thrpt   45  154916.876 ± 1355.639  ops/s
-DZoneReadMapJohnzon.read10FromString    thrpt   45   75610.515 ±  469.744  ops/s
-DZoneReadMapJsonIO.read10FromString     thrpt   45   28445.343 ±  279.304  ops/s
-DZoneReadMapJsonMoshi.read10FromString  thrpt   45   86168.309 ± 1428.668  ops/s
+DZoneReadMapJacksonJr.read10FromString  thrpt   45  183788.845 ± 1926.758  ops/s
+DZoneReadMapFastjson.read10FromString   thrpt   45  172123.796 ± 1628.945  ops/s
+DZoneReadMapJackson.read10FromString    thrpt   45  169171.957 ± 1678.742  ops/s
+DZoneReadMapBoon.read10FromString       thrpt   45  151415.861 ± 1471.262  ops/s
+DZoneReadMapDslJson.read10FromString    thrpt   45  144000.109 ± 2528.670  ops/s
+DZoneReadMapGSON.read10FromString       thrpt   45  136533.317 ± 5371.167  ops/s
+DZoneReadMapJsonMoshi.read10FromString  thrpt   45   72646.224 ±  738.465  ops/s
+DZoneReadMapJsonParse.read10FromString  thrpt   45   65851.568 ±  356.922  ops/s
+DZoneReadMapJohnzon.read10FromString    thrpt   45   64726.343 ±  355.917  ops/s
+DZoneReadMapJsonIO.read10FromString     thrpt   45   29088.020 ±  625.932  ops/s
 ```
 
-In this test, `Boon` has performance slightly exceeding standard Jackson (and only slightly
-below `jackson-jr`); GSON coming in relatively close, and other options being significantly
+In this test, `Fastjson` has performance slightly exceeding standard Jackson (and only slightly
+below `jackson-jr`); GSON and Boon coming in relatively close, and other options being significantly
 slower.
 
 Boon seems to specifically optimized for the combination of "untyped" (Lists, Maps) result, and use of `String` as input. In fact, with bigger input size, `Boon` is the fastest library.
+
+#### Writing 1000 item (POJO) list to Stream
+
+```
+% java -Xmx256m -jar target/microbenchmarks.jar ".*DZoneWrite.*write1kUsingStream" -wi 4 -i 5 -f 9
+
+# Run complete. Total time: 00:14:09
+
+Benchmark                                Mode  Cnt      Score     Error  Units
+DZoneWriteDslJson.write1kUsingStream    thrpt   45  11059.275 ±  71.957  ops/s
+DZoneWriteJacksonAB.write1kUsingStream  thrpt   45   4839.274 ±  58.191  ops/s
+DZoneWriteJackson.write1kUsingStream    thrpt   45   3943.914 ±  56.247  ops/s
+DZoneWriteFastjson.write1kUsingStream   thrpt   45   3619.340 ±  23.558  ops/s
+DZoneWriteJacksonJr.write1kUsingStream  thrpt   45   3500.094 ± 114.309  ops/s
+DZoneWriteBoon.write1kUsingStream       thrpt   45   1985.888 ±  75.288  ops/s
+DZoneWriteJohnzon.write1kUsingStream    thrpt   45   1602.113 ±  18.489  ops/s
+DZoneWriteMoshi.write1kUsingStream      thrpt   45   1282.247 ±  24.045  ops/s
+DZoneWriteJsonIO.write1kUsingStream     thrpt   45    813.591 ±  23.716  ops/s
+DZoneWriteGSON.write1kUsingStream       thrpt   45    542.166 ±  14.094  ops/s
+```
+
+DSL-JSON is much faster when using Stream instead of String. Up to 20x difference than GSON.
+
+
+#### Read 1000 item (POJO) list from Stream
+
+```
+% java -Xmx256m -jar target/microbenchmarks.jar ".*DZoneReadPojo.*read1kFromStream.*” -wi 4 -i 5 -f 9
+
+# Run complete. Total time: 00:13:51
+
+Benchmark                                 Mode  Cnt     Score    Error  Units
+DZoneReadPojoDslJson.read1kFromStream    thrpt   45  3054.305 ± 92.445  ops/s
+DZoneReadPojoJacksonAB.read1kFromStream  thrpt   45  2449.244 ± 40.747  ops/s
+DZoneReadPojoJacksonJr.read1kFromStream  thrpt   45  1982.046 ± 16.049  ops/s
+DZoneReadPojoJackson.read1kFromStream    thrpt   45  1955.585 ± 22.946  ops/s
+DZoneReadPojoFastjson.read1kFromStream   thrpt   45  1450.955 ±  9.774  ops/s
+DZoneReadPojoBoon.read1kFromStream       thrpt   45  1300.449 ± 81.215  ops/s
+DZoneReadPojoGSON.read1kFromStream       thrpt   45  1176.733 ± 14.119  ops/s
+DZoneReadPojoJohnzon.read1kFromStream    thrpt   45   651.262 ± 41.751  ops/s
+DZoneReadPojoMoshi.read1kFromStream      thrpt   45   639.329 ± 22.281  ops/s
+```
+
+DSL-JSON is around 20% faster than Jackson and 5x faster then slowest (Moshi) which doesn’t support Stream input.

pom.xml

@@ -146,16 +146,22 @@
         <dependency>
             <groupId>com.dslplatform</groupId>
             <artifactId>dsl-json</artifactId>
-            <version>0.9.5</version>
+            <version>1.0.0</version>
         </dependency>
 
         <dependency>
             <groupId>com.dslplatform</groupId>
             <artifactId>dsl-json-processor</artifactId>
-            <version>0.4</version>
+            <version>1.0</version>
             <scope>provided</scope>
         </dependency>
 
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.5</version>
+        </dependency>
+
     </dependencies>
 
     <build>

src/main/java/com/cowtowncoder/jsonperf/dzone/read/DZoneReadMapBoon.java

@@ -1,5 +1,6 @@
 package com.cowtowncoder.jsonperf.dzone.read;
 
+import java.io.InputStream;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
@@ -26,6 +27,11 @@ public Map<?,?> _readItems(byte[] input) throws Exception {
         return mapper.readValue(input, Map.class);
     }
 
+    @Override
+    public Map<?,?> _readItems(InputStream input) throws Exception {
+        return mapper.readValue(input, Map.class);
+    }
+
     @Override
     public Map<?,?> _readItems(String input) throws Exception {
         return mapper.readValue(input, Map.class);

src/main/java/com/cowtowncoder/jsonperf/dzone/read/DZoneReadMapDslJson.java

@@ -0,0 +1,40 @@
+package com.cowtowncoder.jsonperf.dzone.read;
+
+import com.dslplatform.json.DslJson;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+
+import java.io.InputStream;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+@State(Scope.Thread)
+@OutputTimeUnit(TimeUnit.SECONDS)
+public class DZoneReadMapDslJson extends DZoneReadTestBase<Map<String, Object>>
+{
+    private final DslJson<Object> dsl;
+    private final byte[] buffer = new byte[8196];
+
+    public DZoneReadMapDslJson()
+    {
+        dsl = new DslJson<>();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public Map<String, Object> _readItems(byte[] input) throws Exception {
+        return dsl.deserialize(Map.class, input, input.length);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public Map<String, Object> _readItems(InputStream input) throws Exception {
+        return dsl.deserialize(Map.class, input, buffer);
+    }
+
+    @Override
+    public Map<String, Object> _readItems(String input) throws Exception {
+        return _readItems(input.getBytes("UTF-8"));
+    }
+}

src/main/java/com/cowtowncoder/jsonperf/dzone/read/DZoneReadMapFastjson.java

@@ -1,5 +1,6 @@
 package com.cowtowncoder.jsonperf.dzone.read;
 
+import java.io.InputStream;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
@@ -25,6 +26,12 @@ public Map<Object,Object> _readItems(byte[] input) throws Exception {
         return (Map<Object,Object>) JSON.parse(input, Feature.DisableCircularReferenceDetect);
     }
 
+    @SuppressWarnings("unchecked")
+    @Override
+    public Map<Object,Object> _readItems(InputStream input) throws Exception {
+        return (Map<Object,Object>) JSON.parseObject(input, Map.class, Feature.DisableCircularReferenceDetect);
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public Map<Object,Object> _readItems(String input) throws Exception {

src/main/java/com/cowtowncoder/jsonperf/dzone/read/DZoneReadMapGSON.java

@@ -24,7 +24,12 @@ public DZoneReadMapGSON()
 
     @Override
     public Map<?,?> _readItems(byte[] input) throws Exception {
-        InputStreamReader r = new InputStreamReader(new ByteArrayInputStream(input), "UTF-8");
+        return _readItems(new ByteArrayInputStream(input));
+    }
+
+    @Override
+    public Map<?,?> _readItems(InputStream input) throws Exception {
+        InputStreamReader r = new InputStreamReader(input, "UTF-8");
         Map<?,?> value = gson.fromJson(r, Map.class);
         r.close();
         return value;

src/main/java/com/cowtowncoder/jsonperf/dzone/read/DZoneReadMapJackson.java

@@ -1,5 +1,6 @@
 package com.cowtowncoder.jsonperf.dzone.read;
 
+import java.io.InputStream;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
@@ -26,6 +27,11 @@ public Map<Object,Object> _readItems(byte[] input) throws Exception {
         return objectReader.readValue(input);
     }
 
+    @Override
+    public Map<Object,Object> _readItems(InputStream input) throws Exception {
+        return objectReader.readValue(input);
+    }
+
     @Override
     public Map<Object,Object> _readItems(String input) throws Exception {
         return objectReader.readValue(input);

src/main/java/com/cowtowncoder/jsonperf/dzone/read/DZoneReadMapJacksonJr.java

@@ -1,5 +1,6 @@
 package com.cowtowncoder.jsonperf.dzone.read;
 
+import java.io.InputStream;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
@@ -25,6 +26,11 @@ public Map<?,?> _readItems(byte[] input) throws Exception {
         return json.mapFrom(input);
     }
 
+    @Override
+    public Map<?,?> _readItems(InputStream input) throws Exception {
+        return json.mapFrom(input);
+    }
+
     @Override
     public Map<?,?> _readItems(String input) throws Exception {
         return json.mapFrom(input);

src/main/java/com/cowtowncoder/jsonperf/dzone/read/DZoneReadMapJohnzon.java

@@ -1,6 +1,7 @@
 package com.cowtowncoder.jsonperf.dzone.read;
 
 import java.io.ByteArrayInputStream;
+import java.io.InputStream;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
@@ -23,8 +24,13 @@ public DZoneReadMapJohnzon()
 
     @Override
     public Map<?,?> _readItems(byte[] input) throws Exception {
+        return _readItems(new ByteArrayInputStream(input));
+    }
+
+    @Override
+    public Map<?,?> _readItems(InputStream input) throws Exception {
         // force assign to ensure casting checks the type
-        Map<?,?> value = mapper.readObject(new ByteArrayInputStream(input), Object.class);
+        Map<?,?> value = mapper.readObject(input, Object.class);
         return value;
     }
 

src/main/java/com/cowtowncoder/jsonperf/dzone/read/DZoneReadMapJsonIO.java

@@ -18,7 +18,12 @@ public DZoneReadMapJsonIO() { }
 
     @Override
     public Map<?,?> _readItems(byte[] input) throws Exception {
-        JsonReader r = new JsonReader(new ByteArrayInputStream(input));
+        return _readItems(new ByteArrayInputStream(input));
+    }
+
+    @Override
+    public Map<?,?> _readItems(InputStream input) throws Exception {
+        JsonReader r = new JsonReader(input);
         Map<?,?> value = (Map<?,?>) r.readObject();
         r.close();
         return value;