Комментарии (6)

1. 

   Gromilo

   07.08.2025 07:57

   #28672990

   За char.IsAsciiDigit спасибо.

   Но что вы там такое делаете, что приходиться бенчить проверки номера? Проверяете номера всего мира несколько раз в сутки?

   
   

   1. 

      srogatnev Автор

      07.08.2025 07:57

      #28673002

      Я не скажу, что есть какие-то проблемы производительности в этом месте. А даже если они и есть, то это далеко не самая критичная часть кода. Это скорее любопытство и попытки лучше разобраться, как это работает. Ну и по возможности, где-то сделать лучше, если это дёшево: например, добавить опцию компиляции регулярного выражения или использовать source generator.

1. 

   OwDafuq

   07.08.2025 07:57

   #28673772

   Попробуйте еще это:

   [Benchmark] public bool IsAllDigit() { var length = str.Length; var span = str.AsSpan(); for (var i = 0; i < length; i++) { if ((uint)(span[i] - '0') > 9) { return false; } } return true; }

   Бенчмарк показывает, что мой метод быстрее, по крайней мере на моей машине

   (извините, не совсем умею на хабре вставлять куски кода правильно)

   
   

   1. 

      srogatnev Автор

      07.08.2025 07:57

      #28674484

      Действительно, можно попробовать такое решение. У меня получились такие результаты:
      

      | Method                  | Runtime            | Mean      | Median    | Allocated |
      |------------------------ |------------------- |----------:|----------:|----------:|
      | IsAllDigit              | .NET Framework 4.8 | 6.3097 ns | 6.2725 ns |         - |
      | IsAllDigit              | .NET Core 3.1      | 4.4434 ns | 4.4404 ns |         - |
      | IsAllDigit              | .NET 6.0           | 4.4595 ns | 4.4046 ns |         - |
      | IsAllDigit              | .NET 9.0           | 3.4871 ns | 3.5038 ns |         - |

      Можно сказать, что он сопоставим с методом IsAsciiDigit и лишь в .NET 9 появляется преимущество.

1. 

   Erty_Hackward

   07.08.2025 07:57

   #28673884

   return value.AsSpan().IndexOfAnyExceptInRange('0', '9') == -1;

1. 

   VBDUnit

   07.08.2025 07:57

   #28674386

   Для интереса попробовал на интринсиках (.NET9/Release):

   | Method                             | Mean              | Error          | StdDev         |
   |----------------------------------- |------------------:|---------------:|---------------:|
   | LEN_12_only_digits                 |          1.668 ns |      0.0088 ns |      0.0083 ns |
   | LEN_12_NOT_only_digits             |          1.099 ns |      0.0062 ns |      0.0055 ns |
   | LEN_256_000_000_only_digits        | 10,137,419.231 ns | 77,538.9046 ns | 64,748.4971 ns |
   | LEN_256_000_000_NOT_only_digits    |  9,201,213.951 ns | 92,295.2075 ns | 81,817.2974 ns |

   • Строки в 12 символов за 1.1 — 1.7 нс

   • Строки в 256 миллионов символов — 10–11 мс

   public static bool IsAllDigits([NotNull] string str)
   {
       unsafe
       {
           fixed (char* begin = str)
           {
               char* ptr = begin;
               var charsInVector = Vector<ushort>.Count;
               if (str.Length >= charsInVector) //Если строка достаточно длинная для векторов
               {
                   //Вычисляем конец чтобы поместилось целое число векторов
                   char* endVector = begin + str.Length / charsInVector * charsInVector;
   
                   var min = new Vector<ushort>((ushort)'0'); //Вектор состоящий из '0'
                   var max = new Vector<ushort>((ushort)'9'); //Вектор состоящий из '9'
   
                   //Идея простая: берем пачки по N символов
                   //загоняем в диапазон от '0' до '9'
                   //и смотрим есть ли изменения - если есть, значит это были не цифры
                   while (ptr < endVector)
                   {
                       var v = Vector.Load((ushort*)ptr); //Загружаем 16 символов в регистр 
                       var vClamped = Vector.ClampNative(v, min, max); //Загоняем в диапазон от '0' до '9'
   
                       if (!Vector.EqualsAll(v, vClamped)) //Если что-то изменилось то там были не только цифры
                           return false;
   
                       ptr += charsInVector; //Идем дальше
                   }
               }
               char* end = begin + str.Length;
   
               //Если осталось хотя бы 8 символов - добиваем 128-битной инструкцией
               if (end - ptr >= Vector128<ushort>.Count)
               {
                   var min128 = Vector128.Create((ushort)'0');
                   var max128 = Vector128.Create((ushort)'9');
                   var v = Vector128.Load<ushort>((ushort*)ptr);
                   if (!Vector128.EqualsAll(Vector128.Clamp(v, min128, max128), v))
                       return false;
                   else
                       ptr += Vector128<ushort>.Count;
               }
              
               //Далее анролл по 4
               char* end4 = begin + (str.Length & ~3);
               while (ptr < end4)
               {
                   if (unchecked((uint)(*ptr - '0')) > 9u) return false; ptr++;
                   if (unchecked((uint)(*ptr - '0')) > 9u) return false; ptr++;
                   if (unchecked((uint)(*ptr - '0')) > 9u) return false; ptr++;
                   if (unchecked((uint)(*ptr - '0')) > 9u) return false; ptr++;
               }
   
               //Потом обычным циклом
               while (ptr < end)
               {
                   if (unchecked((uint)(*ptr - '0')) > 9u)
                       return false;
                   ptr++;
               }
           }
       }
       return true;
   }

   Использование AVX512 прироста не дало

   | Method                             | Mean              | Error          | StdDev         |
   |----------------------------------- |------------------:|---------------:|---------------:|
   | LEN_12_only_digits512              |          1.676 ns |      0.0078 ns |      0.0073 ns |
   | LEN_12_NOT_only_digits512          |          1.101 ns |      0.0063 ns |      0.0059 ns |
   | LEN_256_000_000_only_digits512     | 10,133,206.250 ns | 77,341.0857 ns | 68,560.8580 ns |
   | LEN_256_000_000_NOT_only_digits512 |  9,085,707.091 ns | 53,953.1981 ns | 45,053.3640 ns |

     public static bool IsAllDigits512([NotNull] string str)
     {
         unsafe
         {
             fixed (char* begin = str)
             {
                 char* ptr = begin;
                 var charsInVector512 = Vector512<ushort>.Count;
                 //Основная тушка с векторами
                 if (str.Length >= charsInVector512) //Если строка достаточно длинная для векторов
                 {
                     //Вычисляем конец чтобы поместилось целое число векторов
                     char* endVector512 = begin + str.Length / charsInVector512 * charsInVector512;
   
                     var min = Vector512.Create((ushort)'0'); //Вектор состоящий из '0'
                     var max = Vector512.Create((ushort)'9'); //Вектор состоящий из '9'
   
                     //Идея простая: берем пачки по N символов
                     //загоняем в диапазон от '0' до '9'
                     //и смотрим есть ли изменения - если есть, значит это были не цифры
                     while (ptr < endVector512)
                     {
                         var v = Vector512.Load((ushort*)ptr); //Загружаем 16 символов в регистр 
                         var vClamped = Vector512.ClampNative(v, min, max); //Загоняем в диапазон от '0' до '9'
   
                         if (!Vector512.EqualsAll(v, vClamped)) //Если что-то изменилось то там были не только цифры
                             return false;
   
                         ptr += charsInVector512; //Идем дальше
                     }
                 }
   
                 char* end = begin + str.Length;
   
                 //Если осталось хотя бы 8 символов - добиваем 128-битной инструкцией
                 if (end - ptr >= Vector128<ushort>.Count)
                 {
                     var min128 = Vector128.Create((ushort)'0');
                     var max128 = Vector128.Create((ushort)'9');
                     var v = Vector128.Load<ushort>((ushort*)ptr);
                     if (!Vector128.EqualsAll(Vector128.Clamp(v, min128, max128), v))
                         return false;
                     else
                         ptr += Vector128<ushort>.Count;
                 }
   
                 //Далее анролл по 4
                 char* end4 = begin + (str.Length & ~3);
                 while (ptr < end4)
                 {
                     if (unchecked((uint)(*ptr - '0')) > 9u) return false; ptr++;
                     if (unchecked((uint)(*ptr - '0')) > 9u) return false; ptr++;
                     if (unchecked((uint)(*ptr - '0')) > 9u) return false; ptr++;
                     if (unchecked((uint)(*ptr - '0')) > 9u) return false; ptr++;
                 }
   
                 //Потом обычным циклом
                 while (ptr < end)
                 {
                     if (unchecked((uint)(*ptr - '0')) > 9u)
                         return false;
                     ptr++;
                 }
             }
         }
         return true;
     }

   Код бенчмарка

    public class Benchmark
    {
        static int randomIndex = 0;
        static string generateBigRandomString(bool onlyDigits, int count)
        {
            if (count < 1024)
                throw new NotSupportedException();
            var rnd = new Random(Interlocked.Increment(ref randomIndex));
            var b = new StringBuilder(count);
            var beginNoDigits = count / 10 * 9;
            for (int i = 0; i < count; i++)
                b.Append((char)rnd.Next('0' + 0, '9' + 1));
   
            if (!onlyDigits)
            {
                for (int i = 0; i < 10; i++)
                {
                    var index = rnd.Next(beginNoDigits, count);
                    b[index] = (char)rnd.Next('a' + 0, 'z' + 1);
                }
            }
            return b.ToString();
        }
        string small_only_digits, small;
        string big_only_digits, big;
        [GlobalSetup]
        public void Setup()
        {
            small_only_digits = "123456732890";
            small = "123456732a90";
            big_only_digits = generateBigRandomString(true, 256_000_000);
            big = generateBigRandomString(false, 256_000_000);
        }
   
        [Benchmark] public bool LEN_12_only_digits() => TurboIsDigitChecker.IsAllDigits(small_only_digits);
        [Benchmark] public bool LEN_12_NOT_only_digits() => TurboIsDigitChecker.IsAllDigits(small);
        [Benchmark] public bool LEN_256_000_000_only_digits() => TurboIsDigitChecker.IsAllDigits(big_only_digits);
        [Benchmark] public bool LEN_256_000_000_NOT_only_digits() => TurboIsDigitChecker.IsAllDigits(big);
   
        [Benchmark] public bool LEN_12_only_digits512() => TurboIsDigitChecker.IsAllDigits512(small_only_digits);
        [Benchmark] public bool LEN_12_NOT_only_digits512() => TurboIsDigitChecker.IsAllDigits512(small);
        [Benchmark] public bool LEN_256_000_000_only_digits512() => TurboIsDigitChecker.IsAllDigits512(big_only_digits);
        [Benchmark] public bool LEN_256_000_000_NOT_only_digits512() => TurboIsDigitChecker.IsAllDigits512(big);
    }

   Дальше можно в зависимости от фактического размера данных затачиваться:

   • Под короткие строки — тогда выкидываем тушу с векторами и делаем ступенчатую обработку (по типу блока с Vector128, который под тушкой векторов), то есть сначала один раз без цикла проверяем 512, потом 256, потом 128 бит, потом анролл, потом обычный цикл

   • Под длинные строки — тогда можно перед тушкой с векторами поставить проверку по 1 цифре, которая подравняет указатель памяти до кратности размеру вектора, и далее, в тушке векторов, делать не Load, а LoadAligned, что немного быстрее. Ну и можно поиграться со способом проверки — не Clamp/Equals, а какие‑нибудь хитрые трюки с масками