Reading multiple bytes from an input adapter?

[TianyiChen]

I was looking at binary parsing performance, and noticed get_number is calling get() which calls ia.get_character() and processes the input byte by byte. Since we know the length we are going to handle, I think we might get better performance if the read is done at once like calling fread or ifstream::read for the underlying.

From an old issue: #623 it mentioned return multiple characters as a std::string., but I only saw get_character from current input adapters. Wondering was it a design choice to process input byte-by-byte? Will we consider reading multiple bytes from an input adapter?

[TianyiChen]

I tried a quick benchmark based on code shared at #2581 (reply in thread) , for c style FILE msgpack read, looks the throughput doubled, even tripled in related tests:

develop:

FromMsgpack/jeopardy          1245547333 ns   1210330000 ns            1 bytes_per_second=36.3705Mi/s
FromMsgpack/canada              28926130 ns     28632880 ns           25 bytes_per_second=35.177Mi/s
FromMsgpack/citm_catalog        11033022 ns     10903523 ns           65 bytes_per_second=29.9543Mi/s
FromMsgpack/twitter             10622453 ns     10492791 ns           67 bytes_per_second=36.4927Mi/s
FromMsgpack/floats             166717521 ns    163715750 ns            4 bytes_per_second=52.4267Mi/s
FromMsgpack/signed_ints        171707844 ns    167527000 ns            4 bytes_per_second=51.234Mi/s
FromMsgpack/unsigned_ints      167388344 ns    164910750 ns            4 bytes_per_second=52.0468Mi/s
FromMsgpack/small_signed_ints  102578387 ns    100799000 ns            7 bytes_per_second=46.3689Mi/s

with fread

FromMsgpack/jeopardy          1214922500 ns   1198918000 ns            1 bytes_per_second=36.7166Mi/s
FromMsgpack/canada              28611583 ns     28227240 ns           25 bytes_per_second=35.6825Mi/s
FromMsgpack/citm_catalog        10264158 ns     10140739 ns           69 bytes_per_second=32.2075Mi/s
FromMsgpack/twitter             10467863 ns     10335926 ns           68 bytes_per_second=37.0465Mi/s
FromMsgpack/floats             165293698 ns    162907500 ns            4 bytes_per_second=52.6868Mi/s
FromMsgpack/signed_ints         58535225 ns     57571083 ns           12 bytes_per_second=149.087Mi/s
FromMsgpack/unsigned_ints       55933354 ns     55166750 ns           12 bytes_per_second=155.584Mi/s
FromMsgpack/small_signed_ints   60099170 ns     59261750 ns           12 bytes_per_second=78.8695Mi/s

my implementation used byteswap from C++23, but it's simple to backport should we move forward to a PR

 if constexpr (std::is_integral_v<NumberType> && std::is_same_v<nlohmann::detail::file_input_adapter, InputAdapterType>)
        {
            chars_read += sizeof(NumberType);
            if (JSON_HEDLEY_UNLIKELY(!ia.get_buffer((char*)&result, sizeof(NumberType))))
            {
                sax->parse_error(chars_read, "<end of file>", parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", "number"), nullptr));
                return false;
            }

            if (is_little_endian != (InputIsLittleEndian || format == input_format_t::bjdata))
            {
                result = std::byteswap(result);
            }
            return true;
        }

static void FromMsgpack(benchmark::State& state, const char* filename)
{
    std::ifstream f(filename);
    std::string str((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
    auto bytes = json::to_msgpack(json::parse(str));
    std::ofstream o("/tmp/test.msgpack");
    o.write((char*)bytes.data(), bytes.size());
    o.flush();
    o.close();
    for (auto _ : state)
    {
        state.PauseTiming();
        auto* j = new json();
        auto file = fopen("/tmp/test.msgpack", "rb");
        state.ResumeTiming();

        *j = json::from_msgpack(file);

        state.PauseTiming();
        fclose(file);
        delete j;
        state.ResumeTiming();
    }

    state.SetBytesProcessed(state.iterations()* bytes.size());
}

[nlohmann]

Wow, this is impressive! Happy to see a merge request - as long as it's targeting C++11.

[TianyiChen]

I drafted one, but unsure what to do with wide_string_input_adapter for multi-byte reading, I noticed it uses asserts instead of returning EOF like some other input adapters if a read is attempted while input is exhausted. I am not familiar with wide string processing, not sure even having a multi-byte reader for that adapter makes sense. Currently I am thinking fallback to get_character in a loop. If you have a chance, could you advise?
fa2712d