Bão hòa trừ / cộng cho các byte không dấu

Hãy tưởng tượng tôi có hai byte không dấu bvà x. Tôi cần phải tính toán bsubnhư b - xvà baddnhư b + x. Tuy nhiên, tôi không muốn tràn / tràn dòng xảy ra trong các hoạt động này. Ví dụ (mã giả):

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

và

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

Cách rõ ràng để làm điều này bao gồm phân nhánh:

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

Tôi chỉ tự hỏi nếu có bất kỳ cách nào tốt hơn để làm điều này, tức là bằng một số thao tác bit hacky?

Bài báo Branchfree Saturating Arithmetic cung cấp các chiến lược cho việc này:

Giải pháp bổ sung của họ như sau:

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

    return res;
}

đã sửa đổi cho uint8_t:

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

    return res;
}

và giải pháp trừ của chúng là:

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

    return res;
}

đã sửa đổi cho uint8_t:

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

    return res;
}

Một phương pháp đơn giản là phát hiện tràn và đặt lại giá trị cho phù hợp như bên dưới

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

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

GCC có thể tối ưu hóa kiểm tra tràn thành nhiệm vụ có điều kiện khi biên dịch với -O2.

Tôi đã đo lường mức độ tối ưu hóa so với các giải pháp khác. Với 1000000000+ thao tác trên PC của tôi, giải pháp này và giải pháp của @ShafikYaghmour trung bình là 4,2 giây và của @chux trung bình là 4,8 giây. Giải pháp này cũng dễ đọc hơn.

Đối với phép trừ:

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

Thêm vào:

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

Sự phát triển

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

Nhờ vào @R_Kapp

Nhờ vào @NathanOliver

Bài tập này cho thấy giá trị của việc viết mã đơn giản.

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

Nếu bạn đang sử dụng phiên bản gcc hoặc clang đủ gần đây (có thể cũng có một số phiên bản khác), bạn có thể sử dụng cài sẵn để phát hiện tràn.

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

Ngoài ra:

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

Đối với phép trừ:

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

Không cần toán tử so sánh hoặc phép nhân.

Nếu bạn sẵn sàng sử dụng lắp ráp hoặc bản chất, tôi nghĩ tôi có một giải pháp tối ưu.

Đối với phép trừ:

Chúng ta có thể sử dụng sbb hướng dẫn

Trong MSVC, chúng ta có thể sử dụng hàm nội tại _subborrow_u64 (cũng có sẵn ở các kích thước bit khác).

Đây là cách nó được sử dụng:

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

Đây là cách chúng tôi có thể áp dụng nó vào tình huống của bạn

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;
}

Ngoài ra:

Chúng ta có thể sử dụngadcx hướng dẫn

Trong MSVC, chúng ta có thể sử dụng hàm nội tại _addcarry_u64 (cũng có sẵn ở các kích thước bit khác).

Đây là cách nó được sử dụng:

// *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);

Đây là cách chúng tôi có thể áp dụng nó vào tình huống của bạn

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;
}

Tôi không thích cái này nhiều như cái trừ, nhưng tôi nghĩ nó khá tiện lợi.

Nếu phần bổ sung bị tràn carry_flag = 1,. Not-ing carry_flagcho kết quả là 0, vì vậy !carry_flag * result = 0khi có tràn. Và vì 0 - 1sẽ đặt giá trị tích phân không dấu thành giá trị lớn nhất của nó, hàm sẽ trả về kết quả của phép cộng nếu không có dấu và trả về giá trị lớn nhất của giá trị tích phân đã chọn nếu có dấu.

cái này thì sao:

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

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

Tất cả có thể được thực hiện trong số học byte không dấu

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

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

Nếu bạn muốn thực hiện việc này với hai byte, hãy sử dụng mã đơn giản nhất có thể.

Nếu bạn muốn thực hiện việc này với hai mươi tỷ byte, hãy kiểm tra xem những hướng dẫn vectơ nào có sẵn trên bộ xử lý của bạn và liệu chúng có thể được sử dụng hay không. Bạn có thể thấy rằng bộ xử lý của bạn có thể thực hiện 32 thao tác này với một lệnh duy nhất.

Bạn cũng có thể sử dụng thư viện số an toàn tại Vườn ươm Thư viện Boost . Nó cung cấp các thay thế thả vào cho int, long, v.v., đảm bảo rằng bạn sẽ không bao giờ bị tràn, dòng dưới, v.v. không bị phát hiện.

Nếu bạn gọi các phương thức đó nhiều, thì cách nhanh nhất sẽ không phải là thao tác bit mà có lẽ là bảng tra cứu. Xác định một mảng có độ dài 511 cho mỗi phép toán. Ví dụ cho phép trừ (phép trừ)

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

Mảng là tĩnh và chỉ được khởi tạo một lần. Bây giờ phép trừ của bạn có thể được định nghĩa là phương pháp nội tuyến hoặc sử dụng trình biên dịch trước:

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

Làm thế nào nó hoạt động? Bạn muốn tính trước tất cả các phép trừ có thể có cho các ký tự không dấu. Kết quả thay đổi từ -255 đến +255, tổng số 511 kết quả khác nhau. Chúng tôi xác định một mảng tất cả các kết quả có thể có nhưng vì trong C, chúng tôi không thể truy cập nó từ các chỉ số âm nên chúng tôi sử dụng +255 (trong [A-B + 255]). Bạn có thể loại bỏ hành động này bằng cách xác định một con trỏ ở giữa mảng.

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

sử dụng nó như:

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

Lưu ý rằng quá trình thực hiện cực kỳ nhanh chóng. Chỉ một phép trừ và một sai lệch con trỏ để nhận được kết quả. Không phân nhánh. Các mảng tĩnh rất ngắn nên chúng sẽ được tải đầy đủ vào bộ nhớ đệm của CPU để tăng tốc độ tính toán hơn nữa

Tương tự sẽ hoạt động đối với phép cộng nhưng với một bảng khác một chút (256 phần tử đầu tiên sẽ là chỉ số và 255 phần tử cuối cùng sẽ bằng 255 để mô phỏng mức giới hạn vượt quá 255.

Nếu bạn nhấn mạnh vào phép toán bit, các câu trả lời sử dụng (a> b) là sai. Điều này vẫn có thể được triển khai dưới dạng phân nhánh. Sử dụng kỹ thuật bit ký hiệu

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

Bây giờ bạn có thể sử dụng nó để tính trừ và cộng.

Nếu bạn muốn mô phỏng các hàm max (), min () mà không sử dụng phân nhánh:

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)); }

Các ví dụ của tôi ở trên sử dụng số nguyên 32 bit. Bạn có thể thay đổi nó thành 64, mặc dù tôi tin rằng các phép tính 32 bit chạy nhanh hơn một chút. Tùy thuộc vào bạn