Performance improvements

[TurpentineDistillery]

I propose some minor changes that yield substantial performance improvements.

diff --git a/src/json.hpp b/src/json.hpp
index a302bb0..0a8ab78 100644
--- a/src/json.hpp
+++ b/src/json.hpp
@@ -8755,10 +8755,10 @@ basic_json_parser_66:
                 {
                     // copy unprocessed characters to line buffer
                     m_line_buffer.clear();
-                    for (m_cursor = m_start; m_cursor != m_limit; ++m_cursor)
-                    {
-                        m_line_buffer.append(1, static_cast<const char>(*m_cursor));
-                    }
+                    m_line_buffer.append(
+                            reinterpret_cast<const typename string_t::value_type*>(m_start),
+                            static_cast<size_t>(m_limit - m_start));
+                    m_cursor = m_limit;
                 }

                 // append n characters to make sure that there is sufficient
@@ -8770,11 +8770,13 @@ basic_json_parser_66:
             {
                 // delete processed characters from line buffer
                 m_line_buffer.erase(0, static_cast<size_t>(offset_start));
+
                 // read next line from input stream
-                std::string line;
-                std::getline(*m_stream, line, '\n');
+                m_line_buffer_tmp.clear();
+                std::getline(*m_stream, m_line_buffer_tmp, '\n');
                 // add line with newline symbol to the line buffer
-                m_line_buffer += line + "\n";
+                m_line_buffer += m_line_buffer_tmp;
+                m_line_buffer.push_back('\n');
             }

             // set pointers
@@ -8861,9 +8863,15 @@ basic_json_parser_66:
             // iterate the result between the quotes
             for (const lexer_char_t* i = m_start + 1; i < m_cursor - 1; ++i)
             {
-                // process escaped characters
-                if (*i == '\\')
-                {
+                // number of non-escaped characters
+                const size_t n = static_cast<size_t>(std::find(i, m_cursor - 1, '\\') - i);
+
+                if(n != 0) {
+                    result.append(reinterpret_cast<const typename string_t::value_type*>(i), n);
+                    i += n-1; // -1 because will ++i
+                } else {
+                    // processing escaped character
+
                     // read next character
                     ++i;

@@ -8950,12 +8958,6 @@ basic_json_parser_66:
                         }
                     }
                 }
-                else
-                {
-                    // all other characters are just copied to the end of the
-                    // string
-                    result.append(1, static_cast<typename string_t::value_type>(*i));
-                }
             }

             return result;
@@ -9139,6 +9141,8 @@ basic_json_parser_66:
         std::istream* m_stream = nullptr;
         /// line buffer buffer for m_stream
         string_t m_line_buffer {};
+        /// used for filling m_line_buffer
+        string_t m_line_buffer_tmp {};
         /// the buffer pointer
         const lexer_char_t* m_content = nullptr;
         /// pointer to the beginning of the current symbol

Before
parse jeopardy.json                           1  1746079858 ns/op
parse canada.json                            50    49808100 ns/op
parse citm_catalog.json                      50    30050798 ns/op
parse twitter.json                          100    15523826 ns/op
parse numbers/floats.json                     5   539260495 ns/op
parse numbers/signed_ints.json                5   346619225 ns/op
parse numbers/unsigned_ints.json              5   348103862 ns/op
dump jeopardy.json                            1  1882424034 ns/op
dump jeopardy.json with indent                1  2333816314 ns/op

After:
parse jeopardy.json                           1  1392954141 ns/op
parse canada.json                            50    47828487 ns/op
parse citm_catalog.json                     100    19988139 ns/op
parse twitter.json                          100    10175643 ns/op
parse numbers/floats.json                     5   428099836 ns/op
parse numbers/signed_ints.json                5   232719693 ns/op
parse numbers/unsigned_ints.json              5   234741840 ns/op
dump jeopardy.json                            1  1871500322 ns/op
dump jeopardy.json with indent                1  2512231626 ns/op

[nlohmann]

Very nice!

[nlohmann]

I can confirm the improvements. I shall create a feature branch.

[nlohmann]

There are tests failing with Linux: https://travis-ci.org/nlohmann/json/builds/177884351

[gregmarr]

dump jeopardy.json with indent
Any idea why this one is almost 10% slower?

[nlohmann]

@gregmarr When I ran the benchmarks, I did not notice the deviation. However, the numbers differed from run to run. I shall have a second look and post my results here.

Right now, I need to understand why the tests fail on Linux...

[TurpentineDistillery]

@gregmarr, this must be experimental variance.
BTW, adding the following snippet to benchmarking code may make the results more consistent.

#include <pthread.h>
#include <thread>
struct StartUp
{
    StartUp()
    {
#ifndef __llvm__
        // pin thread to a single CPU
        cpu_set_t cpuset;
        pthread_t thread;
        thread = pthread_self();
        CPU_ZERO(&cpuset);
        CPU_SET(std::thread::hardware_concurrency() - 1, &cpuset);
        pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset);
#endif
    }
};
StartUp startup;
#endif

Why errors though... The changes looked so functionally-invariant to me.

[gregmarr]

Ah, I had assumed that this already did multiple runs and averaged the results to eliminate the variances.

[gregmarr]

I'm not sure if it's causing the failures here, but the reinterpret_cast might be a problem.

-               result.append(1, static_cast<typename string_t::value_type>(*i));

+               result.append(reinterpret_cast<const typename string_t::value_type*>(i), n);

The former essentially converts a character from the lexer type to the string type. If the two types are different sizes, the compiler converts from one to the other.

The latter treats a pointer to an array of lexer character types to a pointer to an array of string character types. If the two character types are different sizes, then this is a major bug as the string data is interpreted improperly. Additionally, if the string character type is larger than the lexer character type, then this is an array out of bounds access.

You probably want to use this overload instead:

template<class InputIt> basic_string& append(InputIt first, InputIt last);

            // find next escape character
            auto e = std::find(i, m_cursor - 1, '\\');

            if(e != i) {
                result.append(i, e);
                i = e-1; // -1 because will ++i
            } else {

Similarly, here:

                m_line_buffer.clear();
                m_line_buffer.append(
                        reinterpret_cast<const typename string_t::value_type*>(m_start),
                        static_cast<size_t>(m_limit - m_start));

should probably be

                m_line_buffer.assign(m_start, m_limit);

Note that with assign you don't need to clear first.

[nlohmann]

The tests seem to succeed, but the benchmarks are not that stable:

[~/.../Repositories/json] ./json_benchmarks_develop --benchtime 60
parse jeopardy.json                          50  2465207545 ns/op
parse canada.json                           500   127668921 ns/op
parse citm_catalog.json                    1000    60734985 ns/op
parse twitter.json                         5000    28945175 ns/op
parse numbers/floats.json                   100   976098389 ns/op
parse numbers/signed_ints.json              100   769079242 ns/op
parse numbers/unsigned_ints.json            100  1079325121 ns/op
dump jeopardy.json                           50  1805855545 ns/op
dump jeopardy.json with indent               50  1806103893 ns/op
./json_benchmarks_develop 1502.94s

[~/.../Repositories/json] ./json_benchmarks_after --benchtime 60
parse jeopardy.json                          50  2137069074 ns/op
parse canada.json                           500   146579088 ns/op
parse citm_catalog.json                    1000    69727750 ns/op
parse twitter.json                         2000    37405801 ns/op
parse numbers/floats.json                    50  1764961957 ns/op
parse numbers/signed_ints.json              100   858041927 ns/op
parse numbers/unsigned_ints.json            100   819768276 ns/op
dump jeopardy.json                           50  1474386834 ns/op
dump jeopardy.json with indent               50  1721278953 ns/op
./json_benchmarks_after 1334.51s

I won't merge this right now. I think there should be an improvement, but it seems to be time to change the benchmarking tool... Any ideas?