Насичуючи віднімання / додавання для непідписаних байтів

Уявіть, у мене є два байти без знака bі x. Мені потрібно обчислити bsubяк b - xі baddяк b + x. Однак я не хочу, щоб під час цих операцій відбувався заниження / переповнення. Наприклад (псевдокод):

b = 3; x = 5;
bsub = b - x; // bsub must be 0, not 254

і

b = 250; x = 10;
badd = b + x; // badd must be 255, not 4

Очевидний спосіб зробити це включає розгалуження:

bsub = b - min(b, x);
badd = b + min(255 - b, x);

Мені просто цікаво, чи є якісь кращі способи зробити це, тобто якимись хакі-маніпуляціями?

Стаття Branchfree Saturating Arithmetic містить стратегії для цього:

Рішення їх додавання таке:

u32b sat_addu32b(u32b x, u32b y)
{
    u32b res = x + y;
    res |= -(res < x);

    return res;
}

змінено для uint8_t:

uint8_t  sat_addu8b(uint8_t x, uint8_t y)
{
    uint8_t res = x + y;
    res |= -(res < x);

    return res;
}

і рішенням їх віднімання є:

u32b sat_subu32b(u32b x, u32b y)
{
    u32b res = x - y;
    res &= -(res <= x);

    return res;
}

змінено для uint8_t:

uint8_t sat_subu8b(uint8_t x, uint8_t y)
{
    uint8_t res = x - y;
    res &= -(res <= x);

    return res;
}

Простий метод - виявити переповнення та скинути значення відповідно, як показано нижче

bsub = b - x;
if (bsub > b)
{
    bsub = 0;
}

badd = b + x;
if (badd < b)
{
    badd = 255;
}

GCC може оптимізувати перевірку переповнення в умовне призначення при компіляції з -O2.

Я виміряв, скільки оптимізації порівняно з іншими рішеннями. При 1000000000+ операціях на моєму ПК це рішення та рішення @ShafikYaghmour складали в середньому 4,2 секунди, а @chux - 4,8 секунди. Це рішення є також більш читабельним.

Для віднімання:

diff = (a - b)*(a >= b);

Додаток:

sum = (a + b) | -(a > (255 - b))

Еволюція

// sum = (a + b)*(a <= (255-b)); this fails
// sum = (a + b) | -(a <= (255 - b)) falis too

Завдяки @R_Kapp

Завдяки @NathanOliver

Ця вправа показує цінність простого кодування.

sum = b + min(255 - b, a);

Якщо ви використовуєте досить недавню версію gcc або clang (можливо, також деякі інші), ви можете використовувати вбудовані системи для виявлення переповнення.

if (__builtin_add_overflow(a,b,&c))
{
  c = UINT_MAX;
}

Додатково:

unsigned temp = a+b;  // temp>>8 will be 1 if overflow else 0
unsigned char c = temp | -(temp >> 8);

Для віднімання:

unsigned temp = a-b;  // temp>>8 will be 0xFF if neg-overflow else 0
unsigned char c = temp & ~(temp >> 8);

Не потрібні оператори порівняння або множення.

Якщо ви бажаєте скористатися складанням або властивостями, я думаю, що я маю оптимальне рішення.

Для віднімання:

Ми можемо скористатися sbbінструкцією

У MSVC ми можемо використовувати внутрішню функцію _subborrow_u64 (також доступна в інших бітових розмірах).

Ось як це використовується:

// *c = a - (b + borrow)
// borrow_flag is set to 1 if (a < (b + borrow))
borrow_flag = _subborrow_u64(borrow_flag, a, b, c);

Ось як ми можемо застосувати це до вашої ситуації

uint64_t sub_no_underflow(uint64_t a, uint64_t b){
    uint64_t result;
    borrow_flag = _subborrow_u64(0, a, b, &result);
    return result * !borrow_flag;
}

Додатково:

Ми можемо скористатися adcxінструкцією

У MSVC ми можемо використовувати внутрішню функцію _addcarry_u64 (також доступна в інших бітових розмірах).

Ось як це використовується:

// *c = a + b + carry
// carry_flag is set to 1 if there is a carry bit
carry_flag = _addcarry_u64(carry_flag, a, b, c);

Ось як ми можемо застосувати це до вашої ситуації

uint64_t add_no_overflow(uint64_t a, uint64_t b){
    uint64_t result;
    carry_flag = _addcarry_u64(0, a, b, &result);
    return !carry_flag * result - carry_flag;
}

Мені це не так подобається, як віднімання, але я думаю, що воно досить витончене.

Якщо додати переповнюється, carry_flag = 1. Not-ing carry_flagдає 0, тому, !carry_flag * result = 0коли є переповнення. А оскільки 0 - 1встановить інтегральне значення без знака на його максимальне значення, функція поверне результат додавання, якщо немає перенесення, і поверне максимальне значення обраного інтегрального значення, якщо є перенесення.

як що до цього:

bsum = a + b;
bsum = (bsum < a || bsum < b) ? 255 : bsum;

bsub = a - b;
bsub = (bsub > a || bsub > b) ? 0 : bsub;

Все може бути зроблено в беззнаковій байтовій арифметиці

// Addition without overflow
return (b > 255 - a) ? 255 : a + b

// Subtraction without underflow
return (b > a) ? 0 : a - b;

Якщо ви хочете зробити це з двома байтами, використовуйте найпростіший можливий код.

Якщо ви хочете зробити це за допомогою двадцяти мільярдів байт, перевірте, які векторні інструкції є на вашому процесорі та чи можна їх використовувати. Ви можете виявити, що ваш процесор може виконати 32 з цих операцій за одну інструкцію.

Ви також можете використовувати безпечну цифрову бібліотеку в Boost Library Incubator . Він пропонує заміни для int, long тощо тощо, які гарантують, що ви ніколи не отримаєте невизначеного переливу, затоплення тощо

Якщо ви будете часто називати ці методи, найшвидшим способом буде не маніпуляція з бітами, а, мабуть, пошукова таблиця. Визначте масив довжиною 511 для кожної операції. Приклад для мінуса (віднімання)

static unsigned char   maxTable[511];
memset(maxTable, 0, 255);           // If smaller, emulates cutoff at zero
maxTable[255]=0;                    // If equal     - return zero
for (int i=0; i<256; i++)
    maxTable[255+i] = i;            // If greater   - return the difference

Масив статичний і ініціалізується лише один раз. Тепер ваше віднімання можна визначити як вбудований метод або за допомогою попереднього компілятора:

#define MINUS(A,B)    maxTable[A-B+255];

Як це працює? Ну, ви хочете заздалегідь розрахувати всі можливі віднімання для беззнакових символів. Результати варіюються від -255 до +255, загалом 511 різний результат. Ми визначаємо масив усіх можливих результатів, але оскільки в C ми не можемо отримати до нього доступ з негативних індексів, ми використовуємо +255 (в [A-B + 255]). Ви можете видалити цю дію, визначивши вказівник на центр масиву.

const unsigned char *result = maxTable+255;
#define MINUS(A,B)    result[A-B];

використовувати його як:

bsub  = MINUS(13,15); // i.e 13-15 with zero cutoff as requested

Зверніть увагу, що виконання надзвичайно швидке. Щоб отримати результат, потрібно лише одне віднімання та одне відхилення покажчика. Без розгалуження. Статичні масиви дуже короткі, тому вони будуть повністю завантажені в кеш процесора для подальшого прискорення обчислення

Те саме буде працювати для додавання, але з дещо іншою таблицею (перші 256 елементів будуть індексами, а останні 255 елементів будуть дорівнювати 255 для емуляції відсікання за 255.

Якщо ви наполягаєте на роботі з бітами, відповіді (a> b) є неправильними. Це все ще може бути реалізовано як розгалуження. Використовуйте техніку розпису знаків

// (num1>num2) ? 1 : 0
#define        is_int_biggerNotEqual( num1,num2) ((((__int32)((num2)-(num1)))&0x80000000)>>31)

Тепер ви можете використовувати його для обчислення віднімання та додавання.

Якщо ви хочете емулювати функції max (), min () без розгалуження, використовуйте:

inline __int32 MIN_INT(__int32 x, __int32 y){   __int32 d=x-y; return y+(d&(d>>31)); }              

inline __int32 MAX_INT(__int32 x, __int32 y){   __int32 d=x-y; return x-(d&(d>>31)); }

У наведених вище прикладах використовуються 32-бітні цілі числа. Ви можете змінити його на 64, хоча я вважаю, що 32-бітні обчислення виконуються трохи швидше. До вас