ReadFloat 8digits unroll performance improvement

[kitaisreal]

I hereby agree to the terms of the CLA available at: https://yandex.ru/legal/cla/?lang=en

https://johnnylee-sde.github.io/Fast-numeric-string-to-int/

CC: @alexey-milovidov

Changelog category (leave one):

• Performance Improvement

Changelog entry:
Slightly improved performance of float parsing.

[alexey-milovidov]

We can also do it for up to 16 digits with SSE2/SSE4.2:

• check that every character in SSE register is in [0..9];
• find position of the first non-matching character.

[kitaisreal]

Nice. Will do.

[kitaisreal]

@alexey-milovidov After implementation using isNext16Digits does not make performance improvements.

[kitaisreal]

@alexey-milovidov this implementation is faster than DB::readIntTextUnsafe when integers are big, and have almost the same performance when they are short.

I also plan to try check why this code

       if (buf.position() + 8 <= buf.buffer().end() && 
            has_next_8_digits_shift(buf.position())) {
            x = x * 100000000 + parse_eight_digits_unrolled(buf.position());
            buf.position() += 8;

            if (buf.position() + 8 <= buf.buffer().end() && 
               has_next_8_digits_shift(buf.position())) {
               x = x * 100000000 + parse_eight_digits_unrolled(buf.position());
               buf.position() += 8;
            }
        }

does not lead to best performance in case of integer parsing, this unrolled bit shift implementations

// credit: https://johnnylee-sde.github.io/Fast-numeric-string-to-int/
fastfloat_really_inline uint32_t parse_eight_digits_unrolled(const char *chars)  noexcept  {
  uint64_t val;
  ::memcpy(&val, chars, sizeof(uint64_t));
  val = (val & 0x0F0F0F0F0F0F0F0F) * 2561 >> 8;
  val = (val & 0x00FF00FF00FF00FF) * 6553601 >> 16;
  return uint32_t((val & 0x0000FFFF0000FFFF) * 42949672960001 >> 32);
}

fastfloat_really_inline bool is_made_of_eight_digits_fast(uint64_t val)  noexcept  {
  return (((val & 0xF0F0F0F0F0F0F0F0) |
           (((val + 0x0606060606060606) & 0xF0F0F0F0F0F0F0F0) >> 4)) ==
          0x3333333333333333);
}


fastfloat_really_inline bool is_made_of_eight_digits_fast(const char *chars)  noexcept  {
  uint64_t val;
  ::memcpy(&val, chars, 8);
  return is_made_of_eight_digits_fast(val);
}

are used in fast_float and when I replace their usage inside fast_float library with MMX or with simple loop like this

        while (!buf.eof())
        {
            if ((*buf.position() & 0xF0) == 0x30)
            {
                x *= 10;
                x += *buf.position() & 0x0F;
                ++buf.position();
            }
            else
                break;
        }

that made performance worse. Plan to investigate that, from my perspective we can definitely improve integer parsing performance, with one of above solutions, just need to carefully bench them.