부호없는 바이트에 대한 포화 빼기 / 더하기

두 개의 unsigned 바이트 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로 컴파일 할 때 오버 플로우 검사를 조건부 할당으로 최적화 할 수 있습니다.

다른 솔루션과 비교하여 최적화 정도를 측정했습니다. 내 PC에서 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;

2 바이트로이 작업을 수행하려면 가능한 가장 간단한 코드를 사용하십시오.

20 억 바이트로이 작업을 수행하려면 프로세서에서 사용할 수있는 벡터 명령과 사용할 수 있는지 확인하십시오. 프로세서가 단일 명령으로 이러한 작업 중 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

실행이 매우 빠릅니다. 결과를 얻기 위해 단 하나의 빼기와 하나의 포인터를 따릅니다. 분기가 없습니다. 정적 배열은 매우 짧기 때문에 계산 속도를 더욱 높이기 위해 CPU 캐시에 완전히로드됩니다.

덧셈에도 동일하게 작동하지만 약간 다른 테이블을 사용합니다 (처음 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 비트 정수를 사용합니다. 32 비트 계산이 조금 더 빨리 실행된다고 생각하지만 64로 변경할 수 있습니다. 당신까지