feat: support cache class for v2/decode (#90)

Author: dead-horse

.jshintrc

@@ -49,7 +49,7 @@
     "lastsemic"     : false,     // true: Tolerate omitting a semicolon for the last statement of a 1-line block
     "laxbreak"      : true,      // true: Tolerate possibly unsafe line breakings
     "laxcomma"      : false,     // true: Tolerate comma-first style coding
-    "loopfunc"      : false,     // true: Tolerate functions being defined in loops
+    "loopfunc"      : true,     // true: Tolerate functions being defined in loops
     "multistr"      : true,      // true: Tolerate multi-line strings
     "proto"         : false,     // true: Tolerate using the `__proto__` property
     "scripturl"     : false,     // true: Tolerate script-targeted URLs

benchmark/buf.txt

@@ -0,0 +1,45 @@
+'use strict';
+
+var Benchmark = require('benchmark');
+var benchmarks = require('beautify-benchmark');
+var path = require('path');
+var fs = require('fs');
+var assert = require('assert');
+var hessian = require('../');
+
+
+var buf = fs.readFileSync(path.join(__dirname, 'buf.txt'));
+var cache = new Map();
+
+assert.deepEqual(hessian.decode(buf, '2.0', { classCache: cache }), hessian.decode(buf, '2.0'));
+assert.deepEqual(hessian.decode(buf, '2.0', { classCache: cache }), hessian.decode(buf, '2.0'));
+var suite = new Benchmark.Suite();
+
+suite
+
+.add('with cache', function() {
+  hessian.decode(buf, '2.0', { classCache: cache });
+})
+.add('without cache', function() {
+  hessian.decode(buf, '2.0');
+})
+
+.on('cycle', function(event) {
+  benchmarks.add(event.target);
+})
+.on('start', function(event) {
+  console.log('\n  Cache Benchmark\n  node version: %s, date: %s\n  Starting...',
+    process.version, Date());
+})
+.on('complete', function done() {
+  benchmarks.log();
+})
+.run({ 'async': false });
+
+// Cache Benchmark
+// node version: v8.5.0, date: Tue Oct 31 2017 17:17:54 GMT+0800 (CST)
+// Starting...
+// 2 tests completed.
+//
+// with cache    x 14,006 ops/sec ±2.21% (83 runs sampled)
+// without cache x  5,506 ops/sec ±1.94% (83 runs sampled)

benchmark/cache.js

@@ -0,0 +1,49 @@
+'use strict';
+
+var Benchmark = require('benchmark');
+var benchmarks = require('beautify-benchmark');
+
+var suite = new Benchmark.Suite();
+
+
+var INNER_CLASS_PROPERTY_REG = /^this\$\d+$/;
+var INNER_CLASS_LABEL = '$$ignore_inner_property$$';
+
+var name1 = 'foobar';
+var name2 = 'this$123';
+var name3 = INNER_CLASS_LABEL;
+
+suite
+
+.add('dynamic', function() {
+  /^this\$\d+/.test(name1);
+  /^this\$\d+/.test(name2);
+})
+.add('static', function() {
+  INNER_CLASS_PROPERTY_REG.test(name1);
+  INNER_CLASS_PROPERTY_REG.test(name2);
+})
+.add('equal', function() {
+  name1 === INNER_CLASS_LABEL;
+  name3 === INNER_CLASS_LABEL;
+})
+
+.on('cycle', function(event) {
+  benchmarks.add(event.target);
+})
+.on('start', function(event) {
+  console.log('\n  Reg Benchmark\n  node version: %s, date: %s\n  Starting...',
+    process.version, Date());
+})
+.on('complete', function done() {
+  benchmarks.log();
+})
+.run({ 'async': false });
+
+// node version: v8.5.0, date: Sat Oct 21 2017 08:00:33 GMT+0800 (CST)
+// Starting...
+// 3 tests completed.
+//
+// dynamic x   8,355,274 ops/sec ±1.00% (85 runs sampled)
+// static  x  10,547,340 ops/sec ±0.90% (89 runs sampled)
+// equal   x 488,054,083 ops/sec ±0.67% (88 runs sampled)

benchmark/reg.js

@@ -18,20 +18,30 @@ var DecoderV2 = exports.DecoderV2 = require('./lib/v2/decoder');
 exports.encoderV1 = new EncoderV1({size: 1024 * 1024});
 exports.encoderV2 = new EncoderV2({size: 1024 * 1024});
 
-exports.decode = function decode(buf, version, withType) {
-  if (typeof version === 'boolean') {
+exports.decode = function decode(buf, version, options) {
+  var classCache;
+  var withType;
+
+  if (version && typeof version !== 'string') {
     // buf, withType, version
     var t = version;
-    version = withType;
-    withType = t;
+    version = options;
+    options = t;
   }
 
+  if (typeof options === 'boolean') {
+    withType = options;
+  }
+  if (typeof options === 'object') {
+    withType = options.withType;
+    classCache = options.classCache;
+  }
   withType = !!withType;
 
   if (version === '2.0') {
-    return new DecoderV2(buf).read(withType);
+    return new DecoderV2(buf, classCache).read(withType);
   }
-  return new DecoderV1(buf).read(withType);
+  return new DecoderV1(buf, classCache).read(withType);
 };
 
 exports.encode = function encode(obj, version) {

index.js

@@ -250,7 +250,6 @@ proto._readUTF8String = function (len) {
   if (!is.number(len)) {
     len = this.byteBuffer.getUInt16();
   }
-
   var startPos = this.byteBuffer.position();
   var head;
   var l;

lib/v1/decoder.js

@@ -24,13 +24,14 @@ var supportES6Map = require('../utils').supportES6Map;
 
 var BYTE_CODES = {};
 
-function Decoder(buf) {
+function Decoder(buf, classCache) {
   DecoderV1.call(this, buf);
   this.BYTE_CODES = BYTE_CODES;
   this.classes = []; // {name: classname, fields: []}
   this.types = [];
 
   this._isLastChunk = false;
+  this.classCache = classCache;
 }
 
 util.inherits(Decoder, DecoderV1);
@@ -511,18 +512,45 @@ proto.readType = function () {
   return type;
 };
 
+// properties match with this$\d+ means inner properties
+// it is useless for node and is circular structure
+var INNER_CLASS_PROPERTY_REG = /^this\$\d+$/;
+var INNER_CLASS_LABEL = '$$ignore_inner_property$$';
+
 proto._readObjectDefinition = function () {
   var classname = this.readString();
+
+  // get class definition from cache
+  var cacheClz = this.classCache && this.classCache.get(classname);
+  if (cacheClz) {
+    this.byteBuffer.skip(cacheClz.length);
+    this.classes.push(cacheClz);
+    return cacheClz;
+  }
+
+  var pos = this.byteBuffer.position();
   var fieldsLength = this.readInt();
   var fields = [];
   for (var i = 0; i < fieldsLength; i++) {
-    fields.push(this.readString());
+    var name = this.readString();
+    if (INNER_CLASS_PROPERTY_REG.test(name)) {
+      name = INNER_CLASS_LABEL;
+    }
+    fields.push(name);
   }
   debug('_readObjectDefinition got %s fields: %j', classname, fields);
-  this.classes.push({
+  var clz = {
     name: classname,
-    fields: fields
-  });
+    fields: fields,
+    length: this.byteBuffer.position() - pos,
+  };
+
+  this.classes.push(clz);
+  // set class definition into cache
+  if (this.classCache) {
+    this.classCache.set(clz.name, clz);
+  }
+  return clz;
 };
 
 /**
@@ -572,7 +600,7 @@ proto.readObject = function (withType) {
   } else {
     this.throwError('readObject', code);
   }
-  
+
   var cls = this.classes[ref];
   debug('readObject %s, ref: %s', cls.name, ref);
 
@@ -586,7 +614,7 @@ proto.readObject = function (withType) {
   for (var i = 0; i < fields.length; i++) {
     var name = fields[i];
     var value = this.read(withType);
-    if (!/^this\$\d+$/.test(name)) {
+    if (name !== INNER_CLASS_LABEL) {
       result.$[name] = value;
     }
   }
@@ -773,7 +801,7 @@ utils.addByteCodes(BYTE_CODES, [
  * v2.0
  * ```
  * map        ::= M(x4d) [type] (value value)* Z
- * 
+ *
  * @see http://hessian.caucho.com/doc/hessian-serialization.html##map
  * ```
  * Represents serialized maps and can represent objects.

lib/v2/decoder.js

@@ -47,9 +47,9 @@
     "istanbul": "*",
     "js-to-java": "2",
     "jshint": "*",
-    "mocha": "*"
+    "mocha": "2"
   },
   "engines": {
     "node": ">= 0.12.0"
   }
-}
+}