Apply recent C optimizations to Java extension

benchmark/encoder.rb

@@ -1,9 +1,14 @@
 require "benchmark/ips"
 require "json"
 require "date"
-require "oj"
 
-Oj.default_options = Oj.default_options.merge(mode: :compat)
+begin
+  require "oj"
+
+  Oj.default_options = Oj.default_options.merge(mode: :compat)
+rescue LoadError
+  # no oj, just do json
+end
 
 if ENV["ONLY"]
   RUN = ENV["ONLY"].split(/[,: ]/).map{|x| [x.to_sym, true] }.to_h
@@ -16,11 +21,11 @@
 end
 
 def implementations(ruby_obj)
-  state = JSON::State.new(JSON.dump_default_options)
-  {
-    json: ["json", proc { JSON.generate(ruby_obj) }],
-    oj: ["oj", proc { Oj.dump(ruby_obj) }],
-  }
+  impls = { json: ["json", proc { JSON.generate(ruby_obj) }] }
+  if defined? Oj
+    impls["oj"] = proc { Oj.dump(ruby_obj) }
+  end
+  impls
 end
 
 def benchmark_encoding(benchmark_name, ruby_obj, check_expected: true, except: [])

benchmark/parser.rb

@@ -1,7 +1,13 @@
 require "benchmark/ips"
 require "json"
-require "oj"
-require "rapidjson"
+begin
+  require "oj"
+rescue LoadError
+end
+begin
+  require "rapidjson"
+rescue LoadError
+end
 
 if ENV["ONLY"]
   RUN = ENV["ONLY"].split(/[,: ]/).map{|x| [x.to_sym, true] }.to_h
@@ -18,9 +24,13 @@ def benchmark_parsing(name, json_output)
 
   Benchmark.ips do |x|
     x.report("json")      { JSON.parse(json_output) } if RUN[:json]
-    x.report("oj")        { Oj.load(json_output) } if RUN[:oj]
-    x.report("Oj::Parser") { Oj::Parser.new(:usual).parse(json_output) } if RUN[:oj]
-    x.report("rapidjson") { RapidJSON.parse(json_output) } if RUN[:rapidjson]
+    if defined?(Oj)
+      x.report("oj")        { Oj.load(json_output) } if RUN[:oj]
+      x.report("Oj::Parser") { Oj::Parser.new(:usual).parse(json_output) } if RUN[:oj]
+    end
+    if defined?(RapidJSON)
+      x.report("rapidjson") { RapidJSON.parse(json_output) } if RUN[:rapidjson]
+    end
     x.compare!(order: :baseline)
   end
   puts

java/src/json/ext/ByteListDirectOutputStream.java

@@ -3,14 +3,72 @@
 import org.jcodings.Encoding;
 import org.jruby.util.ByteList;
 
-import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Arrays;
+
+public class ByteListDirectOutputStream extends OutputStream {
+    private byte[] buffer;
+    private int length;
 
-public class ByteListDirectOutputStream extends ByteArrayOutputStream {
     ByteListDirectOutputStream(int size) {
-        super(size);
+        buffer = new byte[size];
     }
 
     public ByteList toByteListDirect(Encoding encoding) {
-        return new ByteList(buf, 0, count, encoding, false);
+        return new ByteList(buffer, 0, length, encoding, false);
+    }
+
+    @Override
+    public void write(int b) throws IOException {
+        int currentLength = this.length;
+        int newLength = currentLength + 1;
+        byte[] buffer = ensureBuffer(this, newLength);
+        buffer[currentLength] = (byte) b;
+        this.length = newLength;
+    }
+
+    @Override
+    public void write(byte[] bytes, int start, int length) throws IOException {
+        int currentLength = this.length;
+        int newLength = currentLength + length;
+        byte[] buffer = ensureBuffer(this, newLength);
+        System.arraycopy(bytes, start, buffer, currentLength, length);
+        this.length = newLength;
+    }
+
+    @Override
+    public void write(byte[] bytes) throws IOException {
+        int myLength = this.length;
+        int moreLength = bytes.length;
+        int newLength = myLength + moreLength;
+        byte[] buffer = ensureBuffer(this, newLength);
+        System.arraycopy(bytes, 0, buffer, myLength, moreLength);
+        this.length = newLength;
+    }
+
+    private static byte[] ensureBuffer(ByteListDirectOutputStream self, int minimumLength) {
+        byte[] buffer = self.buffer;
+        int myCapacity = buffer.length;
+        int diff = minimumLength - myCapacity;
+        if (diff > 0) {
+            buffer = self.buffer = grow(buffer, myCapacity, diff);
+        }
+
+        return buffer;
+    }
+
+    private static byte[] grow(byte[] oldBuffer, int myCapacity, int diff) {
+        // grow to double current buffer length or capacity + diff, whichever is greater
+        int newLength = myCapacity + Math.max(myCapacity, diff);
+        // check overflow
+        if (newLength < 0) {
+            // try just diff length in case it can fit
+            newLength = myCapacity + diff;
+            if (newLength < 0) {
+                throw new ArrayIndexOutOfBoundsException("cannot allocate array of size " + myCapacity + "+" + diff);
+            }
+        }
+        return Arrays.copyOf(oldBuffer, newLength);
     }
 }

java/src/json/ext/ByteListTranscoder.java

@@ -143,9 +143,11 @@ protected void quoteStart() {
      *               until the character before it.
      */
     protected void quoteStop(int endPos) throws IOException {
+        int quoteStart = this.quoteStart;
         if (quoteStart != -1) {
+            ByteList src = this.src;
             append(src.unsafeBytes(), src.begin() + quoteStart, endPos - quoteStart);
-            quoteStart = -1;
+            this.quoteStart = -1;
         }
     }