Skip to content

Benchmarks and ensure_ascii=False #98

Closed
Closed
Benchmarks and ensure_ascii=False#98

Description

@socketpair
socketpair
opened on Apr 1, 2018

Original JSON (Python 3.6) performance differs completely in performance for unicode strings that contain non-us-ascii characters. So, could you provide performance comparison for case ensure_ascii=False and national symbols in source strings? I mean dumps() / dump(). This is important since size of JSON document with ensure_ascii=True is mush bigger than with False.

for example, .dumps('привет, мир!' * 1000)

Activity

  1. lelit commented on Apr 25, 2018

    @lelit
    lelit
    on Apr 25, 2018
    Contributor

    Sorry for taking so long to answer...

    I added such a benchmark, but at first it does not seem very interesting: the difference between ensure_ascii=True (the default) and ensure_ascii=False is lost in the noise:

    ----------------------------------------------------------------------------------- benchmark 'Ensure ASCII string: deserialize': 2 tests ------------------------------------------------------------------------------------
Name (time in us)                                          Min                 Max                Mean            StdDev              Median               IQR            Outliers  OPS (Kops/s)            Rounds  Iterations
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
test_loads_plain_ascii[ASCII-Ensure ASCII string]     101.4790 (1.0)      207.7490 (1.14)     102.9231 (1.0)      3.7238 (1.0)      102.3850 (1.0)      0.3740 (1.0)       201;608        9.7160 (1.0)        9501           1
test_loads_plain_ascii[UTF8-Ensure ASCII string]      101.5060 (1.00)     182.8170 (1.0)      103.1897 (1.00)     4.0251 (1.08)     102.4125 (1.00)     0.3850 (1.03)      362;785        9.6909 (1.00)       9058           1
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------ benchmark 'Ensure ASCII string: serialize': 2 tests -------------------------------------------------------------------------------------
Name (time in us)                                          Min                 Max                Mean            StdDev              Median               IQR            Outliers  OPS (Kops/s)            Rounds  Iterations
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
test_dumps_plain_ascii[UTF8-Ensure ASCII string]      104.3650 (1.0)      192.9190 (1.05)     106.2129 (1.0)      3.2259 (1.07)     105.6360 (1.0)      0.5793 (1.0)       289;681        9.4150 (1.0)        7577           1
test_dumps_plain_ascii[ASCII-Ensure ASCII string]     105.7220 (1.01)     184.3960 (1.0)      107.7050 (1.01)     3.0031 (1.0)      107.0425 (1.01)     0.7110 (1.23)      378;939        9.2846 (0.99)       9038           1
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

  2. socketpair commented on Apr 25, 2018

    @socketpair
    socketpair
    on Apr 25, 2018
    Author

    Did you use national symbols and how long was you samples ?

  3. lelit commented on Apr 25, 2018

    @lelit
    lelit
    on Apr 25, 2018
    Contributor

    Uhm, I stand corrected, there was a glitch in the pytest parametrization...

    ----------------------------------------------------------------------------------- benchmark 'Ensure ASCII string: deserialize': 2 tests ------------------------------------------------------------------------------------
Name (time in us)                                          Min                 Max                Mean            StdDev              Median               IQR            Outliers  OPS (Kops/s)            Rounds  Iterations
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
test_loads_plain_ascii[UTF8-Ensure ASCII string]       55.2730 (1.0)      111.8980 (1.0)       55.9388 (1.0)      1.8668 (1.0)       55.7290 (1.0)      0.4070 (1.0)       268;500       17.8767 (1.0)       13178           1
test_loads_plain_ascii[ASCII-Ensure ASCII string]     101.7080 (1.84)     181.9020 (1.63)     103.4041 (1.85)     3.5641 (1.91)     102.6190 (1.84)     0.5450 (1.34)     421;1277        9.6708 (0.54)       9435           1
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------ benchmark 'Ensure ASCII string: serialize': 2 tests -------------------------------------------------------------------------------------
Name (time in us)                                          Min                 Max                Mean            StdDev              Median               IQR            Outliers  OPS (Kops/s)            Rounds  Iterations
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
test_dumps_plain_ascii[UTF8-Ensure ASCII string]       58.6200 (1.0)      106.2680 (1.0)       60.1724 (1.0)      2.2044 (1.0)       59.7330 (1.0)      0.4600 (1.0)       526;740       16.6189 (1.0)       10821           1
test_dumps_plain_ascii[ASCII-Ensure ASCII string]     105.9980 (1.81)     201.5630 (1.90)     108.9658 (1.81)     3.7346 (1.69)     108.2050 (1.81)     1.3070 (2.84)      349;891        9.1772 (0.55)       8846           1
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    And this more reasonable, given that:

    >>> import rapidjson
>>> a="привет, мир!"*1000
>>> print(len(rapidjson.dumps(a, ensure_ascii=False)))
12002
>>> print(len(rapidjson.dumps(a, ensure_ascii=True)))
57002

  4. socketpair commented on Apr 25, 2018

    @socketpair
    socketpair
    on Apr 25, 2018
    Author

    Could you please benchmarks "привет, мир!"*1000 for these cases:

    1. json.dumps(a, ensure_ascii=True)
    2. rapidjson.dumps(a, ensure_ascii=True)
    3. json.dumps(a, ensure_ascii=False)
    4. rapidjson.dumps(a, ensure_ascii=False)

    it would be very interesting. And the same for long pure-ascii string.

  5. lelit commented on Apr 25, 2018

    @lelit
    lelit
    on Apr 25, 2018
    Contributor

    I used your sample data, going to commit in a while, so you can try it by yourself

  6. lelit commented on Apr 25, 2018

    @lelit
    lelit
    on Apr 25, 2018
    Contributor

    Now it starts to be interesting indeed!

    ------------------------------------------------------------------------------------------ benchmark 'Long Unicode string: deserialize': 8 tests -------------------------------------------------------------------------------------------
Name (time in us)                                                      Min                 Max                Mean             StdDev              Median                IQR            Outliers  OPS (Kops/s)            Rounds  Iterations
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
test_loads_plain_ascii[stdlib json utf8-Long Unicode string]       16.8020 (1.0)       51.0660 (1.0)       17.1450 (1.0)       1.2180 (1.0)       16.9980 (1.0)       0.0830 (1.0)      552;2847       58.3262 (1.0)       37826           1
test_loads_plain_ascii[simplejson utf8-Long Unicode string]        29.8990 (1.78)      80.8060 (1.58)      30.4024 (1.77)      1.5681 (1.29)      30.2290 (1.78)      0.1180 (1.42)     408;1775       32.8922 (0.56)      23665           1
test_loads_plain_ascii[rapidjson utf8-Long Unicode string]         55.3150 (3.29)     115.0490 (2.25)      56.1359 (3.27)      2.7599 (2.27)      55.8310 (3.28)      0.4140 (4.99)      219;647       17.8139 (0.31)      13313           1
test_loads_plain_ascii[ujson utf8-Long Unicode string]             71.4840 (4.25)     143.4970 (2.81)      72.8053 (4.25)      2.8582 (2.35)      71.7500 (4.22)      2.9350 (35.36)     255;201       13.7353 (0.24)      10935           1
test_loads_plain_ascii[rapidjson ascii-Long Unicode string]       101.5660 (6.04)     188.4630 (3.69)     103.3672 (6.03)      3.8300 (3.14)     102.4950 (6.03)      0.5290 (6.37)     446;1139        9.6743 (0.17)       9368           1
test_loads_plain_ascii[ujson ascii-Long Unicode string]           140.7980 (8.38)     244.6880 (4.79)     145.1342 (8.47)      7.5079 (6.16)     141.2060 (8.31)      6.2615 (75.44)    1270;314        6.8902 (0.12)       6588           1
test_loads_plain_ascii[simplejson ascii-Long Unicode string]      663.6170 (39.50)    876.4680 (17.16)    670.7003 (39.12)    11.8285 (9.71)     668.5860 (39.33)     3.5830 (43.17)       85;98        1.4910 (0.03)       1234           1
test_loads_plain_ascii[stdlib json ascii-Long Unicode string]     696.9850 (41.48)    936.0930 (18.33)    714.4408 (41.67)    20.1182 (16.52)    706.2415 (41.55)    21.4480 (258.42)      95;44        1.3997 (0.02)       1172           1
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------- benchmark 'Long Unicode string: serialize': 8 tests -------------------------------------------------------------------------------------------
Name (time in us)                                                      Min                 Max                Mean            StdDev              Median                IQR            Outliers  OPS (Kops/s)            Rounds  Iterations
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
test_dumps_plain_ascii[stdlib json utf8-Long Unicode string]       45.8210 (1.0)       97.1610 (1.0)       50.2585 (1.0)      6.5866 (5.01)      46.0670 (1.0)      11.6880 (147.95)   3891;228       19.8971 (1.0)       15542           1
test_dumps_plain_ascii[rapidjson utf8-Long Unicode string]         58.3210 (1.27)     101.0680 (1.04)      60.1994 (1.20)     1.7760 (1.35)      59.6380 (1.29)      1.5650 (19.81)     270;167       16.6115 (0.83)      11621           1
test_dumps_plain_ascii[ujson utf8-Long Unicode string]             63.3800 (1.38)     106.8010 (1.10)      63.6902 (1.27)     1.3152 (1.0)       63.5320 (1.38)      0.0790 (1.0)      399;1065       15.7010 (0.79)      14095           1
test_dumps_plain_ascii[ujson ascii-Long Unicode string]            66.4100 (1.45)     149.7220 (1.54)      67.0342 (1.33)     2.3894 (1.82)      66.7110 (1.45)      0.1340 (1.70)     374;1243       14.9178 (0.75)      14264           1
test_dumps_plain_ascii[stdlib json ascii-Long Unicode string]      72.7030 (1.59)     143.1390 (1.47)      79.7810 (1.59)     4.6568 (3.54)      81.9610 (1.78)      4.6500 (58.86)     3592;98       12.5343 (0.63)      13168           1
test_dumps_plain_ascii[simplejson utf8-Long Unicode string]        77.2190 (1.69)     123.2600 (1.27)      77.7460 (1.55)     2.1293 (1.62)      77.4510 (1.68)      0.1100 (1.39)      318;800       12.8624 (0.65)      10316           1
test_dumps_plain_ascii[simplejson ascii-Long Unicode string]       83.7560 (1.83)     157.3020 (1.62)      84.9710 (1.69)     3.4546 (2.63)      83.8740 (1.82)      0.3352 (4.24)     296;2665       11.7687 (0.59)      11349           1
test_dumps_plain_ascii[rapidjson ascii-Long Unicode string]       104.2010 (2.27)     186.2880 (1.92)     105.8934 (2.11)     3.1824 (2.42)     105.4940 (2.29)      0.8180 (10.35)     163;460        9.4435 (0.47)       8676           1
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    Will double check and refine the benchmarks before committing...

  7. socketpair commented on Apr 25, 2018

    @socketpair
    socketpair
    on Apr 25, 2018
    Author

    Grrrrr. even worse. Seems results will be completely different with ensure_ascii=True/False.

  8. socketpair commented on Apr 25, 2018

    @socketpair
    socketpair
    on Apr 25, 2018
    Author

    Please do not intermix different cases in same result set.

    Clearly, every library should be tested with:

    4 cases (for dumps) should be tested:
    dumps(ascii, ensure_ascii=True)
    dumps(ascii, ensure_ascii=False)
    dumps(utf8, ensure_ascii=True)
    dumps(utf8, ensure_ascii=False)

    And 3 for loads():
    loads(ascii)
    loads(utf-8 from ensure_ascci=True)
    loads(utf-8 from ensure_ascci=False)

  9. lelit commented on Apr 25, 2018

    @lelit
    lelit
    on Apr 25, 2018
    Contributor

    Last run for today:

    ------------------------------------------------------------------------------------------ benchmark 'Long ASCII string: deserialize': 8 tests ------------------------------------------------------------------------------------------
Name (time in us)                                                        Min                Max               Mean            StdDev             Median               IQR            Outliers  OPS (Kops/s)            Rounds  Iterations
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
test_loads_long_plain_ascii[stdlib json ascii-Long ASCII string]     20.1970 (1.0)      61.9990 (1.21)     20.4234 (1.0)      0.7386 (1.0)      20.3680 (1.0)      0.0710 (1.65)     454;1326       48.9633 (1.0)       39063           1
test_loads_long_plain_ascii[stdlib json utf8-Long ASCII string]      20.2100 (1.00)     59.8390 (1.17)     20.4767 (1.00)     0.9268 (1.25)     20.3910 (1.00)     0.0730 (1.70)     447;1465       48.8361 (1.00)      33214           1
test_loads_long_plain_ascii[ujson ascii-Long ASCII string]           20.9240 (1.04)     57.2970 (1.12)     21.3493 (1.05)     1.6682 (2.26)     21.0600 (1.03)     0.0430 (1.0)     1363;3053       46.8399 (0.96)      43627           1
test_loads_long_plain_ascii[ujson utf8-Long ASCII string]            20.9410 (1.04)     59.1490 (1.15)     21.2778 (1.04)     1.2022 (1.63)     21.0600 (1.03)     0.0540 (1.26)     435;4193       46.9974 (0.96)      24867           1
test_loads_long_plain_ascii[rapidjson utf8-Long ASCII string]        22.0330 (1.09)     51.3130 (1.0)      22.4540 (1.10)     0.8418 (1.14)     22.3560 (1.10)     0.2530 (5.88)     512;2445       44.5354 (0.91)      37763           1
test_loads_long_plain_ascii[rapidjson ascii-Long ASCII string]       22.0530 (1.09)     63.2240 (1.23)     22.4810 (1.10)     0.8382 (1.13)     22.4050 (1.10)     0.2590 (6.02)     369;2540       44.4819 (0.91)      37441           1
test_loads_long_plain_ascii[simplejson utf8-Long ASCII string]       23.3240 (1.15)     51.8040 (1.01)     23.5896 (1.16)     0.7868 (1.07)     23.4950 (1.15)     0.0780 (1.81)     300;2074       42.3916 (0.87)      28407           1
test_loads_long_plain_ascii[simplejson ascii-Long ASCII string]      23.4970 (1.16)     74.3560 (1.45)     23.8343 (1.17)     1.0675 (1.45)     23.6810 (1.16)     0.0870 (2.02)     644;4109       41.9564 (0.86)      33374           1
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------- benchmark 'Long ASCII string: serialize': 8 tests --------------------------------------------------------------------------------------------
Name (time in us)                                                        Min                 Max               Mean            StdDev             Median               IQR            Outliers  OPS (Kops/s)            Rounds  Iterations
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
test_dumps_long_plain_ascii[ujson ascii-Long ASCII string]           11.7590 (1.0)       45.6920 (1.0)      12.1251 (1.0)      0.6219 (1.0)      12.0330 (1.0)      0.0730 (1.40)    431;12001       82.4736 (1.0)       67463           1
test_dumps_long_plain_ascii[rapidjson utf8-Long ASCII string]        23.2600 (1.98)      56.3220 (1.23)     24.4649 (2.02)     1.0976 (1.76)     24.3520 (2.02)     0.3110 (5.98)     580;1055       40.8750 (0.50)      32224           1
test_dumps_long_plain_ascii[ujson utf8-Long ASCII string]            23.8290 (2.03)      64.6780 (1.42)     24.0290 (1.98)     1.0632 (1.71)     23.9270 (1.99)     0.0520 (1.0)      383;2063       41.6163 (0.50)      34268           1
test_dumps_long_plain_ascii[stdlib json ascii-Long ASCII string]     29.7470 (2.53)      84.1610 (1.84)     32.1950 (2.66)     3.2951 (5.30)     29.8790 (2.48)     6.1120 (117.54)   8921;113       31.0607 (0.38)      26977           1
test_dumps_long_plain_ascii[simplejson ascii-Long ASCII string]      32.5030 (2.76)      86.5870 (1.90)     35.1032 (2.90)     4.3003 (6.91)     32.6070 (2.71)     9.1410 (175.78)    6883;52       28.4875 (0.35)      27176           1
test_dumps_long_plain_ascii[stdlib json utf8-Long ASCII string]      45.8580 (3.90)      94.7250 (2.07)     46.3064 (3.82)     1.8478 (2.97)     46.0200 (3.82)     0.0720 (1.38)     364;1588       21.5953 (0.26)      16039           1
test_dumps_long_plain_ascii[rapidjson ascii-Long ASCII string]       48.4180 (4.12)      96.8690 (2.12)     48.6975 (4.02)     1.5478 (2.49)     48.5250 (4.03)     0.0600 (1.15)     377;1058       20.5349 (0.25)      18892           1
test_dumps_long_plain_ascii[simplejson utf8-Long ASCII string]       76.7090 (6.52)     127.0270 (2.78)     77.6015 (6.40)     3.0345 (4.88)     76.9100 (6.39)     0.1170 (2.25)     232;1763       12.8863 (0.16)      11079           1
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------ benchmark 'Long Unicode string: deserialize': 8 tests -------------------------------------------------------------------------------------------
Name (time in us)                                                       Min                 Max                Mean             StdDev              Median               IQR            Outliers  OPS (Kops/s)            Rounds  Iterations
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
test_loads_long_unicode[stdlib json utf8-Long Unicode string]       16.9440 (1.0)       46.0750 (1.0)       17.2259 (1.0)       0.7482 (1.0)       17.1560 (1.0)      0.0930 (1.21)     313;1423       58.0520 (1.0)       35834           1
test_loads_long_unicode[simplejson utf8-Long Unicode string]        30.1150 (1.78)      71.6830 (1.56)      30.4128 (1.77)      0.9061 (1.21)      30.3250 (1.77)     0.0770 (1.0)      283;1078       32.8809 (0.57)      23593           1
test_loads_long_unicode[rapidjson utf8-Long Unicode string]         55.3990 (3.27)     125.9010 (2.73)      56.1127 (3.26)      1.9153 (2.56)      55.9420 (3.26)     0.3850 (5.00)      322;445       17.8213 (0.31)      13245           1
test_loads_long_unicode[ujson utf8-Long Unicode string]             71.6610 (4.23)     121.8380 (2.64)      72.2767 (4.20)      2.2621 (3.02)      71.8890 (4.19)     0.1190 (1.55)     649;1168       13.8357 (0.24)      13232           1
test_loads_long_unicode[rapidjson ascii-Long Unicode string]       101.7010 (6.00)     170.6430 (3.70)     103.4051 (6.00)      2.9010 (3.88)     102.6430 (5.98)     0.7820 (10.16)    692;1190        9.6707 (0.17)       9429           1
test_loads_long_unicode[ujson ascii-Long Unicode string]           140.9340 (8.32)     228.7520 (4.96)     144.6153 (8.40)      6.8369 (9.14)     141.3380 (8.24)     0.7242 (9.41)    1338;1482        6.9149 (0.12)       6639           1
test_loads_long_unicode[simplejson ascii-Long Unicode string]      658.8740 (38.89)    896.9360 (19.47)    665.0604 (38.61)    12.0372 (16.09)    663.4505 (38.67)    3.8500 (50.00)       59;68        1.5036 (0.03)       1270           1
test_loads_long_unicode[stdlib json ascii-Long Unicode string]     742.9580 (43.85)    891.5590 (19.35)    750.0403 (43.54)    12.5105 (16.72)    746.5425 (43.51)    2.8230 (36.67)     123;142        1.3333 (0.02)       1158           1
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------- benchmark 'Long Unicode string: serialize': 8 tests -------------------------------------------------------------------------------------------
Name (time in us)                                                       Min                 Max                Mean            StdDev              Median               IQR            Outliers  OPS (Kops/s)            Rounds  Iterations
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
test_dumps_long_unicode[stdlib json utf8-Long Unicode string]       45.9740 (1.0)       87.8440 (1.0)       48.4393 (1.0)      4.7606 (2.54)      46.1530 (1.0)      0.1250 (1.81)    3472;4140       20.6444 (1.0)       18590           1
test_dumps_long_unicode[rapidjson utf8-Long Unicode string]         58.4350 (1.27)     119.6510 (1.36)      60.0785 (1.24)     1.8708 (1.0)       59.6910 (1.29)     0.7727 (11.20)     219;679       16.6449 (0.81)      11775           1
test_dumps_long_unicode[ujson utf8-Long Unicode string]             63.5400 (1.38)     116.7150 (1.33)      64.0427 (1.32)     1.9401 (1.04)      63.7150 (1.38)     0.1050 (1.52)     326;1758       15.6146 (0.76)      13801           1
test_dumps_long_unicode[ujson ascii-Long Unicode string]            66.6040 (1.45)     131.0350 (1.49)      68.1483 (1.41)     3.1058 (1.66)      68.2090 (1.48)     1.3990 (20.28)     266;330       14.6739 (0.71)      13258           1
test_dumps_long_unicode[stdlib json ascii-Long Unicode string]      72.8170 (1.58)     136.2430 (1.55)      78.2968 (1.62)     4.5566 (2.44)      77.5170 (1.68)     9.1490 (132.60)    4408;63       12.7719 (0.62)      13093           1
test_dumps_long_unicode[simplejson utf8-Long Unicode string]        77.3590 (1.68)     130.8050 (1.49)      77.8035 (1.61)     1.9467 (1.04)      77.5720 (1.68)     0.1150 (1.67)      274;704       12.8529 (0.62)      10225           1
test_dumps_long_unicode[simplejson ascii-Long Unicode string]       83.9520 (1.83)     190.9580 (2.17)      84.7497 (1.75)     2.6318 (1.41)      84.0660 (1.82)     0.0690 (1.0)     1291;1949       11.7994 (0.57)      11296           1
test_dumps_long_unicode[rapidjson ascii-Long Unicode string]       105.9480 (2.30)     187.1400 (2.13)     107.4564 (2.22)     2.7622 (1.48)     107.0470 (2.32)     0.4960 (7.19)      207;608        9.3061 (0.45)       8904           1
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  10. lelit
    changed the title [-]Benchamrks and ensure_asccii=False[/-] [+]Benchmarks and ensure_ascii=False[/+] on Apr 25, 2018

  11. lelit commented on Apr 25, 2018

    @lelit
    lelit
    on Apr 25, 2018
    Contributor

    There is no ensure_ascii for loads(). And the comparison for dumps() cover those cases exactly.

  12. lelit commented on May 11, 2018

    @lelit
    lelit
    on May 11, 2018
    Contributor

    This is in tabular form:

    +-------------------------+----------------------+----------------------+----------------------+----------------------+----------------------+----------------------+----------------------+----------------------+
|        serialize        |  ``rj ascii``\ [13]  |  ``rj utf8``\ [14]   |  ``uj ascii``\ [15]  |  ``uj utf8``\ [16]   |  ``sj ascii``\ [17]  |  ``sj utf8``\ [18]   | ``json ascii``\ [19] | ``json utf8``\ [20]  |
+=========================+======================+======================+======================+======================+======================+======================+======================+======================+
|    Long ASCII string    |         1.00         |         0.47         |       **0.25**       |         0.52         |         0.71         |         1.41         |         0.64         |         1.21         |
+-------------------------+----------------------+----------------------+----------------------+----------------------+----------------------+----------------------+----------------------+----------------------+
|   Long Unicode string   |         1.00         |         0.63         |         0.64         |         0.65         |         0.79         |         0.61         |         1.01         |       **0.55**       |
+-------------------------+----------------------+----------------------+----------------------+----------------------+----------------------+----------------------+----------------------+----------------------+
|         overall         |         1.00         |         0.58         |       **0.52**       |         0.61         |         0.77         |         0.85         |         0.90         |         0.75         |
+-------------------------+----------------------+----------------------+----------------------+----------------------+----------------------+----------------------+----------------------+----------------------+

    I will commit once I polish a bit the script used to create the table above.

  13. lelit
    added a commit that references this issue on May 11, 2018

    Add a benchmark test to compare ensure_ascii=True|False

    fd4d12f

  14. lelit commented on Jun 6, 2018

    @lelit
    lelit
    on Jun 6, 2018
    Contributor

    Thank you, the new table is present in the just released version 0.6.0 doc.

  15. lelit
    closed this as completedon Jun 6, 2018
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions