python serialization speed comparison

install-setup.txt

virtualenv --no-site-packages hodor
hodor/bin/pip install simplejson ujson cbor tnetstring msgpack-python
curl -s 'http://www.json-generator.com/api/json/get/cvfsLVmKiG?indent=2' > test.json
hodor/bin/python shootout.py

results.txt

## python 2.7.7 on centos 6.6
..::DUMPS::..
        json:	3.068149	 100.00%	90460	 100.00%
  simplejson:	5.616200	 183.05%	90460	 100.00%
       ujson:	1.875687	  61.13%	89261	  98.67%
  tnetstring:	1.162987	  37.91%	90207	  99.72%
     msgpack:	1.110323	  36.19%	86798	  95.95%
        cbor:	0.678674	  22.12%	86778	  95.93%
     marshal:	1.896508	  61.81%	91600	 101.26%
      pickle:	42.890038	1397.91%	91162	 100.78%
     pickle2:	47.861820	1559.96%	87499	  96.73%
     cPickle:	7.550282	 246.09%	91452	 101.10%
    cPickle2:	1.689119	  55.05%	85602	  94.63%

..::LOADS::..
  serializer	time		time-diff
        json:	7.419880	 100.00%
  simplejson:	2.558231	  34.48%
       ujson:	2.890960	  38.96%
  tnetstring:	1.000095	  13.48%
     msgpack:	0.858918	  11.58%
        cbor:	0.947492	  12.77%
     marshal:	0.975319	  13.14%
      pickle:	35.305399	 475.82%
     pickle2:	20.916351	 281.90%
     cPickle:	4.277538	  57.65%
    cPickle2:	1.347456	  18.16%

## [PyPy 2.4.0 with GCC 4.8.2] on centos 6.6
## note: tests probably don't run long enough to get much JIT benefit
..::DUMPS::..
  serializer	time		time-diff	size	size-diff
        json:	4.242018	 100.00%	90460	 100.00%
  simplejson:	17.838388	 420.52%	90460	 100.00%
       ujson: tests failed: 'ujson'
  tnetstring:	6.875353	 162.08%	90207	  99.72%
     msgpack:	3.891492	  91.74%	86798	  95.95%
        cbor:	4.522691	 106.62%	86778	  95.93%
     marshal:	5.291648	 124.74%	91600	 101.26%
      pickle:	22.375729	 527.48%	95288	 105.34%
     pickle2:	9.940469	 234.33%	89020	  98.41%
     cPickle:	25.145335	 592.77%	95291	 105.34%
    cPickle2:	10.484767	 247.16%	89023	  98.41%

..::LOADS::..
  serializer	time		time-diff
        json:	3.343928	 100.00%
  simplejson:	15.526334	 464.31%
       ujson: tests failed: 'ujson'
  tnetstring:	67.718456	2025.12%
     msgpack:	1.826920	  54.63%
        cbor:	6.167334	 184.43%
     marshal:	4.911089	 146.87%
      pickle:	9.324833	 278.86%
     pickle2:	7.627817	 228.11%
     cPickle:	8.596466	 257.08%
    cPickle2:	7.294959	 218.16%

shootout.py

import sys
import random

import json
import simplejson
try:
    import ujson
except ImportError:
    pass
import tnetstring
import marshal
import pickle
import cPickle
import cbor
import msgpack
import functools

from tnetstring.tests.test_format import FORMAT_EXAMPLES, get_random_object

class P(object):
    pass

pickle2 = P()
pickle2.dumps = functools.partial(pickle.dumps, protocol=2)
pickle2.loads = pickle.loads
sys.modules['pickle2'] = pickle2

cPickle2 = P()
cPickle2.dumps = functools.partial(cPickle.dumps, protocol=2)
cPickle2.loads = cPickle.loads
sys.modules['cPickle2'] = cPickle2

try:
    import __pypy__
    tnetstrng = tnetstring
    tnetstring = P()
    tnetstring.dumps = functools.partial(tnetstrng.dumps, encoding="utf8")
    tnetstring.loads = functools.partial(tnetstrng.loads, encoding="utf8")
    sys.modules['tnetstring'] = tnetstring
except:
    pass

# test.json generated from http://www.json-generator.com/
# http://www.json-generator.com/api/json/get/cvfsLVmKiG?indent=2
testdict = simplejson.load(open('test.json','rb'))

def thrasher(serializer):
    m = sys.modules[serializer]
    dumper = getattr(m, 'dumps')
    loader = getattr(m, 'loads')
    def thrash():
        assert loader(dumper(testdict)) == testdict
    return thrash


def thrash_loads(serializer):
    m = sys.modules[serializer]
    dumper = getattr(m, 'dumps')
    loader = getattr(m, 'loads')
    data = dumper(testdict)
    def thrash():
        loader(data)
    return thrash

def thrash_dumps(serializer):
    m = sys.modules[serializer]
    dumper = getattr(m, 'dumps')
    def thrash():
        dumper(testdict)
    return thrash


PERMUTATIONS=10000

def print_round(name, tx, to, l=0, jl=0):
    if l or jl:
        print "%12s:\t%f\t%7.2f%%\t%d\t%7.2f%%" % (
            name, tx,
            round((tx / to) * 100,2),
            l,
            round((l / jl) * 100,2))
    else:
        print "%12s:\t%f\t%7.2f%%" % (
            name, tx,
            round((tx / to) * 100,2))


if __name__ == "__main__":
    import timeit
    tmodules = ("simplejson", "ujson", "tnetstring", "msgpack", "cbor",
                "marshal", "pickle", "pickle2", "cPickle", "cPickle2")
    if len(sys.argv) > 1:
        tmodules = sys.argv[1].split(',')

    print "..::DUMPS::.."
    print "%12s\t%s\t\t%s\t%s\t%s" % ("serializer","time","time-diff","size", "size-diff")
    to = timeit.Timer(
        "dumps()",
        "from shootout import thrash_dumps;dumps=thrash_dumps('json')")
    to =to.timeit(number=PERMUTATIONS)
    jlen = float(len(json.dumps(testdict)))
    print_round("json", to, to, jlen, jlen)

    for x in tmodules:
        try:
            tx = timeit.Timer(
                "dumps()",
                "from shootout import thrash_dumps;dumps=thrash_dumps('%s')" % x)
            tx = tx.timeit(number=PERMUTATIONS)
            m = sys.modules[x]
            print_round(x, tx, to, len(m.dumps(testdict)), jlen)
        except Exception as e:
            print "%12s: tests failed: %s" % (x, e)

    print ""

    print "..::LOADS::.."
    print "%12s\t%s\t\t%s" % ("serializer","time","time-diff")
    to = timeit.Timer(
        "loads()",
        "from shootout import thrash_loads;loads=thrash_loads('json')")
    to =to.timeit(number=PERMUTATIONS)
    print_round("json", to, to)

    for x in tmodules:
        try:
            tx = timeit.Timer(
                "loads()",
                "from shootout import thrash_loads;loads=thrash_loads('%s')" % x)
            tx = tx.timeit(number=PERMUTATIONS)
            m = sys.modules[x]
            print_round(x, tx, to)
        except Exception as e:
            print "%12s: tests failed: %s" % (x, e)

Tested on my Acer Chromebook 14 with Ubuntu 16.04 Crouton, Python 2.7.13

My objects contain really large long values. That is why ujson and msgpack fails. I think it is also important to have that detail.

Python 3.6 on Win7:
Pickle performs really well there.

..::DUMPS::..
  serializer    time            time-diff       size    size-diff
        json:   5.227366         100.00%        90460    100.00%
  simplejson:   6.327719         121.05%        90460    100.00%
     msgpack:   2.010781          38.47%        86798     95.95%
     marshal:   0.669897          12.82%        86909     96.07%
      pickle:   0.984644          18.84%        89020     98.41%
     pickle2:   0.964434          18.45%        89020     98.41%
     pickle4:   0.918402          17.57%        85625     94.66%

..::LOADS::..
  serializer    time            time-diff
        json:   3.465400         100.00%
  simplejson:   3.461371          99.88%
     msgpack:   0.914066          26.38%
     marshal:   0.827754          23.89%
      pickle:   1.156223          33.36%
     pickle2:   1.111155          32.06%
     pickle4:   1.088305          31.40%

Python 3.6.6 on Mac:

..::DUMPS::..
  serializer	time		time-diff	size	size-diff
        json:	4.442723	 100.00%	90460	 100.00%
  simplejson:	4.867349	 109.56%	90460	 100.00%
       ujson:	2.020214	  45.47%	89261	  98.67%
     msgpack:	0.740636	  16.67%	86798	  95.95%
     marshal:	0.623901	  14.04%	86909	  96.07%
        cbor:	1.372539	  30.89%	86778	  95.93%
      pickle:	0.989589	  22.27%	89020	  98.41%

..::LOADS::..
  serializer	time		time-diff
        json:	3.099072	 100.00%
  simplejson:	2.870310	  92.62%
       ujson:	3.670731	 118.45%
     msgpack:	1.002717	  32.36%
     marshal:	1.046321	  33.76%
        cbor:	1.803092	  58.18%
      pickle:	1.298057	  41.89%

python3 compatible code is here: https://gist.github.com/crhan/f04ddb7373533bae4d051271497e080e

python 3.6.6 on Mac:

difference:

1. use a json data length is: 4978960
2. PERMUTATIONS = 100