Как сделать неподписанное дополнение насыщения в C?

В ARM Вы, возможно, уже насыщали встроенную арифметику. Расширения DSP ARMv5 могут насыщать регистры к любой длине в битах. Также на насыщенности ARM является обычно дешевым, потому что Вы можете экс-милый большая часть условного выражения инструкций.

ARMv6 даже насыщал дополнение, вычитание и все другие материал для 32 битов и упаковал числа.

На x86 Вы получаете влажную арифметику или через MMX или через SSE.

Всему этому нужен ассемблер, таким образом, это не то, что Вы попросили.

существуют C-приемы, чтобы сделать насыщаемую арифметику также. Этот небольшой код делает насыщаемое дополнение на четырех байтах dword. Это основано на идее вычислить 32 полусумматора параллельно, например, добавляющие числа без переполнения переноса.

Это сделано сначала. Тогда переносы вычисляются, добавляются и заменяются маской, если дополнение переполнилось бы.

uint32_t SatAddUnsigned8(uint32_t x, uint32_t y) 
{
  uint32_t signmask = 0x80808080;
  uint32_t t0 = (y ^ x) & signmask;
  uint32_t t1 = (y & x) & signmask;
  x &= ~signmask;
  y &= ~signmask;
  x += y;
  t1 |= t0 & x;
  t1 = (t1 << 1) - (t1 >> 7);
  return (x ^ t0) | t1;
}

можно получить то же для 16 битов (или любой вид битового поля) путем изменения signmask константы и сдвигов в нижней части как это:

uint32_t SatAddUnsigned16(uint32_t x, uint32_t y) 
{
  uint32_t signmask = 0x80008000;
  uint32_t t0 = (y ^ x) & signmask;
  uint32_t t1 = (y & x) & signmask;
  x &= ~signmask;
  y &= ~signmask;
  x += y;
  t1 |= t0 & x;
  t1 = (t1 << 1) - (t1 >> 15);
  return (x ^ t0) | t1;
}

uint32_t SatAddUnsigned32 (uint32_t x, uint32_t y)
{
  uint32_t signmask = 0x80000000;
  uint32_t t0 = (y ^ x) & signmask;
  uint32_t t1 = (y & x) & signmask;
  x &= ~signmask;
  y &= ~signmask;
  x += y;
  t1 |= t0 & x;
  t1 = (t1 << 1) - (t1 >> 31);
  return (x ^ t0) | t1;
}

Выше кода делает то же для 16 и 32 битовых значений.

, Если Вам не нужна функция, что функции добавляют и насыщают несколько значений в параллели просто, кашируют биты, в которых Вы нуждаетесь. На ARM Вы также хотите изменить signmask константу, потому что ARM не может загрузить все возможные константы на 32 бита в единственном цикле.

Редактирование: параллельные версии, скорее всего, медленнее, чем прямые методы, но они быстрее, если необходимо насыщать больше чем одно значение за один раз.

В IA32 без условных переходов:

uint32_t sadd32(uint32_t a, uint32_t b)
{
#if defined IA32
  __asm
  {
    mov eax,a
    xor edx,edx
    add eax,b
    setnc dl
    dec edx
    or eax,edx
  }
#elif defined ARM
  // ARM code
#else
  // non-IA32/ARM way, copy from above
#endif
}

В плоскости C:

uint16_t sadd16(uint16_t a, uint16_t b)
    { return (a > 0xFFFF - b) ? 0xFFFF : a + b; }

uint32_t sadd32(uint32_t a, uint32_t b)
    { return (a > 0xFFFFFFFF - b) ? 0xFFFFFFFF : a + b;} 

, который является почти macro-ized и непосредственно передает значение.

Текущая реализация, которую мы используем:

#define sadd16(a, b)  (uint16_t)( ((uint32_t)(a)+(uint32_t)(b)) > 0xffff ? 0xffff : ((a)+(b)))
#define sadd32(a, b)  (uint32_t)( ((uint64_t)(a)+(uint64_t)(b)) > 0xffffffff ? 0xffffffff : ((a)+(b)))

Решение с нулевым переходом:

uint32_t sadd32(uint32_t a, uint32_t b)
{
    uint64_t s = (uint64_t)a+b;
    return -(s>>32) | (uint32_t)s;
}

Хороший компилятор оптимизирует это, чтобы избежать каких-либо фактических 64-битных арифметических действий ( s >> 32 просто - флаг переноса, а - (s >> 32) - результат sbb% eax,% eax ).

В x86 asm (синтаксис AT&T, a и b в eax и ebx , результат в eax ]):

add %eax,%ebx
sbb %eax,%eax
or %ebx,%eax

8- и 16-битные версии должны быть очевидны. Подписанная версия может потребовать немного больше работы.