web-dev-qa-db-ja.com

整数演算を使用してビットごとの演算子を実装することは可能ですか？

私はかなり奇妙な問題に直面しています。私は、ビット単位の演算をサポートしないアーキテクチャー向けのコンパイラーに取り組んでいます。ただし、これは符号付き16ビット整数演算を処理し、次のものだけを使用してビット単位の演算を実装できるかどうか疑問に思っていました。

  • 加算（c = a + b）
  • 減算（c = a-b）
  • Division（c = a/b）
  • 乗算（c = a * b）
  • 係数（c = a％b）
  • 最小（c = min（a、b））
  • 最大（c = max（a、b））
  • 比較（c =（a <b）、c =（a == b）、c =（a <= b）、et.c。）
  • Jumps（goto、for、et.c。）

サポートできるビット単位の操作は次のとおりです。

  • または（c = a | b）
  • And（c = a＆b）
  • Xor（c = a ^ b）
  • 左シフト（c = a << b）
  • 右シフト（c = a >> b）
  • （すべての整数は符号付きなので、これは問題です）
  • 符号付きシフト（c = a >>> b）
  • 1の補数（a =〜b）
  • （すでに解決策を見つけました。以下を参照してください）

通常、問題はその逆です。ビットごとのハックを使用して算術最適化を達成する方法。ただし、この場合はそうではありません。

このアーキテクチャでは、書き込み可能なメモリは非常に少ないであるため、ビット単位の演算が必要です。ビット単位関数自体は、多くの一時変数を使用するべきではありません。ただし、一定の読み取り専用データと命令メモリは豊富です。ここでの注意点は、ジャンプと分岐は高価ではなく、すべてのデータがすぐにキャッシュされることです。ジャンプのコストは、算術（ロード/ストアを含む）命令の半分のサイクルです。言い換えると、上記のサポートされている関数はすべて、1回のジャンプのサイクルの2倍のコストがかかります。

役立つかもしれないいくつかの考え：

次のコードで1の補数（ビットを否定）ができることを理解しました。

// Bitwise one's complement
b = ~a;
// Arithmetic one's complement
b = -1 - a;

2の累乗で除算するときの古いシフトハックも覚えているので、ビットごとのシフトは次のように表すことができます。

// Bitwise left shift
b = a << 4;
// Arithmetic left shift
b = a * 16; // 2^4 = 16

// Signed right shift
b = a >>> 4;
// Arithmetic right shift
b = a / 16;

残りのビット演算については、私は少し無知です。このアーキテクチャのアーキテクトがビット操作を提供してくれることを願っています。

また、メモリデータテーブルを使用せずに2つの累乗（シフト演算用）を計算する高速/簡単な方法があるかどうかも知りたいです。素朴な解決策は、乗算の分野に飛び込むことです：

b = 1;
switch (a)
{
  case 15: b = b * 2;
  case 14: b = b * 2;
  // ... exploting fallthrough (instruction memory is magnitudes larger)
  case 2: b = b * 2;
  case 1: b = b * 2;
}

または、セット＆ジャンプアプローチ：

switch (a)
{
  case 15: b = 32768; break;
  case 14: b = 16384; break;
  // ... exploiting the fact that a jump is faster than one additional mul
  //     at the cost of doubling the instruction memory footprint.
  case 2: b = 4; break;
  case 1: b = 2; break;
}
bitwise-operatorsdiscrete-mathematicscompiler-optimization
55
Statement

シフトの最初のソリューション（シフトはシフト距離であり、負であってはなりません。aはシフトされるオペランドであり、実行時の結果も含まれます）。パワーテーブルは、3つのシフト操作すべてで使用されます。

// table used for shift operations
powtab = { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, -32768 };

// logical shift left
if (shift > 15) {
     a = 0; // if shifting more than 15 bits to the left, value is always zero
} else {
     a *= powtab[shift];
}

// logical shift right (unsigned)
if (shift > 15) {
    a = 0; // more than 15, becomes zero
} else if (shift > 0) {
    if (a < 0) {
        // deal with the sign bit (15)
        a += -32768;
        a /= powtab[shift];
        a += powtab[15 - shift];
    } else {
        a /= powtab[shift];
    }
}

// arithmetic shift right (signed)
if (shift >= 15) {
    if (a < 0) {
        a = -1;
    } else {
        a = 0;
    }
} else if (shift > 0) {
    if (a < 0) {
        // deal with the sign bit
        a += -32768;
        a /= powtab[shift];
        a -= powtab[15 - shift];
    } else {
        // same as unsigned shift
        a /= powtab[shift];
    }
}

ANDの場合、ORおよびXOR私は簡単な解決策を思い付くことができなかったので、各単一ビットをループしてそれを行います。これを行うためのより良いトリック。疑似コードは、aとbが入力オペランド、cが結果値、xがループカウンター（各ループは正確に16回実行される必要がある）を想定しています。

// XOR (^)
c = 0;
for (x = 0; x <= 15; ++x) {
    c += c;
    if (a < 0) {
        if (b >= 0) {
            c += 1;
        }
    } else if (b < 0) {
        c += 1;
    }
    a += a;
    b += b;
}

// AND (&)
c = 0;
for (x = 0; x <= 15; ++x) {
    c += c;
    if (a < 0) {
        if (b < 0) {
            c += 1;
        }
    }
    a += a;
    b += b;
}

// OR (|)
c = 0;
for (x = 0; x <= 15; ++x) {
    c += c;
    if (a < 0) {
        c += 1;
    } else if (b < 0) {
        c += 1;
    }
    a += a;
    b += b;
}

これは、すべての変数が16ビットであり、すべての演算が符号付きとして動作することを前提としています（したがって、ビット15が設定されている場合、実際にはa <0が真です）。

編集：私は実際に、正確さのために0から31までの範囲のシフトについてすべての可能なオペランド値（-32768から32767）をテストし、それは正しく動作します（整数除算を想定）。 AND/OR/XORコードの場合、私のマシンでは徹底的なテストに時間がかかりすぎますが、これらのコードは非常に単純なので、とにかくEdgeケースはありません。

24
Durandal

この環境では、実際に算術演算子を使用して整数のコンポーネントを抽出するように設定できれば最適かもしれません。

例えば。

if (a & 16)  becomes if ((a % 32) > 15)
a &= 16 becomes if ((a % 32) < 15) a += 16

これらの演算子の変換は、RHSを一定の2の累乗に制限すれば十分明白です。

2ビットまたは4ビットを剥がすのも簡単です。

5
Joshua

あなたがそれが非常に高価になることをいとわない限り、そうです。

基本的に、明示的に数値をbase-2表現に入れます。これは、数値をbase-10に入力するのと同じように（たとえば、出力するために）、つまり繰り返し除算することによって行います。

これにより、数値がブール値の配列（または0、1の範囲の整数）に変換され、それらの配列を操作する関数が追加されます。

繰り返しますが、これはビット単位の演算よりも非常に高価であり、ほとんどすべてのアーキテクチャがビット単位の演算子を提供するということではありません。

Cでは（もちろん、Cにはビット単位の演算子がありますが...）実装は次のようになります。

include <limits.h>
const int BITWIDTH = CHAR_BIT;
typedef int[BITWIDTH] bitpattern;

// fill bitpattern with base-2 representation of n
// we used an lsb-first (little-endian) representation
void base2(char n, bitpattern array) {
  for( int i = 0 ; i < BITWIDTH ; ++i ) {
    array[i] = n % 2 ;
    n /= 2 ;
  }
}

void bitand( bitpattern op1, bitpattern op2, bitpattern result ) {
  for( int i = 0 ; i < BITWIDTH ; ++i ) {
    result[i] = op1[i] * op2[i];
  }
}


void bitor( bitpattern op1, bitpattern op2, bitpattern result ) {
  for( int i = 0 ; i < BITWIDTH ; ++i ) {
    result[i] = (op1[i] + op2[i] != 0 );
  }
}

// assumes compiler-supplied bool to int conversion 
void bitxor( bitpattern op1, bitpattern op2, bitpattern result ) {
  for( int i = 0 ; i < BITWIDTH ; ++i ) {
    result[i] = op1[i] != op2[i]  ;
  }
}
2
tpdi

遅くなるすべてのビットを抽出することにより、（Mark Byersが示唆するように）ビットごとに操作できます。

または、プロセスを加速して、2つの4ビットオペランドの結果を格納する2Dルックアップテーブルを使用して、それらを操作することもできます。ビットを操作していた場合よりも、必要な抽出は少なくなります。

また、加算、減算、および> =演算を使用してすべてを実行できます。すべてのビット演算は、マクロを使用して次のようなものに展開できます。

/*I didn't actually compile/test it, it is just illustration for the idea*/
uint16 and(uint16 a, uint16 b){
    uint16 result = 0;
    #define AND_MACRO(c) \
        if (a >= c){ \ 
            if (b >= c){\
                result += c;\
                b -= c;\
            }\
            a -= c;\
        }\
        else if (b >= c)\
            b -= c;

    AND_MACRO(0x8000)
    AND_MACRO(0x4000)
    AND_MACRO(0x2000)
    AND_MACRO(0x1000)
    AND_MACRO(0x0800)
    AND_MACRO(0x0400)
    AND_MACRO(0x0200)
    AND_MACRO(0x0100)
    AND_MACRO(0x0080)
    AND_MACRO(0x0040)
    AND_MACRO(0x0020)
    AND_MACRO(0x0010)
    AND_MACRO(0x0008)
    AND_MACRO(0x0004)
    AND_MACRO(0x0002)
    AND_MACRO(0x0001)
    #undef AND_MACRO
    return result;
}

これを実装するには、3つの変数が必要です。

すべてのビット演算はAND_MACROと同様のマクロを中心に展開されます-aとbの残りの値を「マスク」（「c」パラメーター）と比較します。次に、操作に適したif分岐の結果にマスクを追加します。そして、ビットが設定されている場合は、値からマスクを減算します。

プラットフォームによっては、％および/を使用してすべてのビットを抽出し、乗算を使用して元に戻すよりも高速な場合があります。

どちらが良いか自分で確かめてください。

2
SigTerm

他のいくつかのアプローチ

たとえば16ビットAND：

int and(int a, int b) {
    int d=0x8000;
    int result=0;
    while (d>0)  {
        if (a>=d && b>=d) result+=d;
        if (a>=d) a-=d;
        if (b>=d) b-=d;
        d/=2;
    }
    return result;
}

double解法2-bit ANDループまたはテーブル検索なし：

int and(int a, int b) {
    double x=a*b/12;
    return (int) (4*(sign(ceil(tan(50*x)))/6+x));
}

2ビット整数ソリューション2ビットAND：

int and(int a, int b) {
    return ((684720128*a*a -b) * a) % (b+1);
}

16ビット整数ソリューション2ビットAND：

int and(int a, int b) {
    return ((121 * a) % 16) % (b+1);
}

16ビット整数ソリューションビットAND：

int and(int a, int b) {
    return sign(a) * ((((-23-a) * (40+b)) % 2)+40+b) % ((10624 * ((((-23-a) * (40+b))%2)+40+b)) % (a%2 - 2 -a) - a%2 + 2 +a);
}
1
Bob Genom