Быстрый strlen с битовыми операциями

код "работает", пытаясь прочитать 4 байта за раз, предполагая, что строка выложена и доступна как массив int. Код читает первый int и затем каждый байт по очереди, проверяя, является ли он нулевым символом. Теоретически, код работает с int будет работать быстрее, чем 4 отдельныеchar операции.

но есть несколько проблем:

выравнивание является проблемой: например *(unsigned*)s may seg-fault.

Endian является проблемой с if((x & 0xFF) == 0) может не получить байт по адресу s

s += 4 проблема как sizeof(int) может отличаться от 4.

типы массивов могут превышать int диапазон, лучше использовать size_t.

попытка исправить эти трудности.

#include <stddef.h>
#include <stdio.h>

static inline aligned_as_int(const char *s) {
  max_align_t mat; // C11
  uintptr_t i = (uintptr_t) s;
  return i % sizeof mat == 0;
}

size_t strlen_my(const char *s) {
  size_t len = 0;
  // align
  while (!aligned_as_int(s)) {
    if (*s == 0) return len;
    s++;
    len++;
  }
  for (;;) {
    unsigned x = *(unsigned*) s;
    #if UINT_MAX >> CHAR_BIT == UCHAR_MAX
      if(!(x & 0xFF) || !(x & 0xFF00)) break;
      s += 2, len += 2;
    #elif UINT_MAX >> CHAR_BIT*3 == UCHAR_MAX
      if (!(x & 0xFF) || !(x & 0xFF00) || !(x & 0xFF0000) || !(x & 0xFF000000)) break;
      s += 4, len += 4;
    #elif UINT_MAX >> CHAR_BIT*7 == UCHAR_MAX
      if (   !(x & 0xFF) || !(x & 0xFF00)
          || !(x & 0xFF0000) || !(x & 0xFF000000)
          || !(x & 0xFF00000000) || !(x & 0xFF0000000000)
          || !(x & 0xFF000000000000) || !(x & 0xFF00000000000000)) break;
      s += 8, len += 8;
    #else
      #error TBD code
    #endif
  }
  while (*s++) {
    len++;
  }
  return len;
}

он торгует неопределенным поведением (unaligned accesses, 75% вероятность доступа за пределами конца массива) для очень сомнительного ускорения (это, возможно, даже медленнее). И не соответствует стандарту, потому что он возвращает int вместо size_t. Даже если на платформе разрешены несогласованные доступы, они могут быть намного медленнее, чем выровненные.

он также не работает на системах big-endian, или если unsigned не 32 бита. Не говоря уже о множественной маске и условные операции.

что сказал:

он проверяет 4 8-битных байта за раз, загружая unsigned (который даже не гарантирован иметь больше чем 16 битов). Как только любой из байтов содержит ''-terminator, он возвращает сумму текущей длины плюс положение этого байта. В противном случае он увеличивает текущую длину на количество байтов, проверенных параллельно (4), и получает следующее unsigned.

мой совет: плохой пример оптимизации плюс слишком много неопределенности/подводные камни. Скорее всего, это даже не быстрее - просто профиль его против стандартной версии:

size_t strlen(restrict const char *s)
{
    size_t l = 0;
    while ( *s++ )
        l++;
    return l;
}

может быть способ использовать специальные векторные инструкции, но если вы не можете доказать, что это критическая функция, вы должны оставить это компилятору - некоторые могут развернуть/ускорить такие циклы намного лучше.

все предложения там медленнее, чем простой strlen().

причина в том, что они не уменьшают количество сравнений и только одна касается выравнивания.

Проверьте предложение strlen() от Torbjorn Granlund (tege@sics.se) и Дэн Сахлин (dan@sics.se) в сети. Если вы находитесь на 64-битной платформе, это действительно помогает ускорить работу.

Он определяет, установлены ли какие-либо биты в определенном байте на машине с небольшим концом. Поскольку мы проверяем только один байт (так как все кусочки, 0 или 0xF, удваиваются), и это случается с последней позицией байта (поскольку машина мало-конечная, и байтовый шаблон для чисел, следовательно, обращен), мы можем сразу узнать, какой байт содержит NUL.

цикл принимает 4 байта массива char для каждой итерации. Четыре оператора if используются для определения того, закончена ли строка, используя битовую маску с оператором AND для чтения состояния i-го элемента выбранной подстроки.