2


0

C / C ++のビット配列に対する2つの操作
// b: uint32_t array of size n    => 32*n bits
// The bit index, i, is in the range 0 <= i < 32 * n
// The bit in b at bit index 0 is always 0!

unsigned idx_of_first_zero_bit_before_or_at (uint32_t *b, unsigned n, unsigned i) {
    // Returns a bit index, k, such that k <= i and k is the largest bit index
    // for which bit k in b is 0.
}

// As above, value == 0 or 1
void set_bit (uint32_t *b, unsigned n, unsigned i, unsigned value) {
    // Sets bit at bit index i to value.
    // It could be something like (untested):
    if (value)
        b[i >> 5] |=   (1 << (i&31));
    else
        b[i >> 5] &= (~(1 << (i&31)));
}

私は、これらの機能(特に最初の機能)を実装するための、最も効率的ですが、(異なるターゲット間で移植可能ですが、g ++コンパイラのみを使用する)方法を探しています。 ビットの格納順序(ビッグ、リトルエンディアン、その他)は関係ありません。

単純な実装(テストなし):

uint32_t get_bit (uint32_t *b, unsigned n, unsigned i) {
    return b[i >> 5] & (1 << (i&31));
}

unsigned idx_of_first_zero_bit_before_or_at (uint32_t *b, unsigned n, unsigned i) {
    while (get_bit (b, n, i))
        i--;
    return i;
}

すべての1要素をスキップする:

unsigned idx_of_first_zero_bit_before_or_at (uint32_t *b, unsigned n, unsigned i) {
    for (unsigned k = i >> 5; ~(b[k]) == 0; i = (--k << 5) + 31);
    while (get_bit (b, n, i))
        i--;
    return i;
}

3 Answer


2


使用可能なストレージの量に応じて、ルックアップテーブルアプローチを使用できます。 たとえば、256バイトを使用できる場合、次の関数は1つの `uint32_t`に対してそれを実行します。

static const int table[256] = {
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
    3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 0, 0,
};


int func(uint32_t b, int i)
{
    b = (b << (31-i));

    if ((b & 0xFFFF0000) != 0xFFFF0000)
    {
        return ((b & 0xFF000000) != 0xFF000000)
             ? table[(b >> 24) & 0xFF] + 24 - (31-i)
             : table[(b >> 16) & 0xFF] + 16 - (31-i);
    }
    else
    {
        return ((b & 0xFF00) != 0xFF00)
             ? table[(b >> 8) & 0xFF] + 8 - (31-i)
             : table[(b >> 0) & 0xFF] + 0 - (31-i);
    }
}

これはさらに最適化できると確信しています。 たとえば、確かに高価な条件分岐を排除する方法があります。ブール条件が「1」または「0」のいずれかに評価されるという事実を使用し、それらを被乗数として使用できます。

64kBを使用できる場合、一度に16ビットチャンクでこれを行います。 もちろん、大きなテーブルでランダムアクセスを行うと、キャッシュ効果が発生する可能性があるため、実験してプロファイルを作成する必要があります。


0


通常、「ランダムな」分岐を回避しようとします。 たとえば、オリチャールズワースが提案したソリューションを使用して、「if」を取り除くことができます。

LUTを使用してほとんどの計算を解決しますが、最後の部分にはまだブランチが必要です。 それに対処する追加のLUTを導入します。

unsigned index2 = table[ b        & 0xFF]        |  // Values 0..7, so we use 3 bits
                 (table[(b >>  8) & 0xFF] << 3 ) |  // Next 3 bits..
                 (table[(b >> 16) & 0xFF] << 6 ) |
                 (table[(b >> 24) & 0xFF] << 9 );

`index2`には12ビットの値があり、単一のテーブル検索で意味のある値に変換できます:

return table2[index2]; // char[4096] array with precomputed values.

また、最初に16ビットLUTを使用することで、2つの16ビットルックアップと8ビットのルックアップが最終的に行われます。


0


バイナリ検索を使用して、1つのuint32内でゼロビットを見つけることができます。 最後のいくつかの手順をルックアップテーブルに置き換えて、LUTのメモリフットプリントと命令のバランスを取ることもできます。 まず、制御フローを備えたソリューション:

unsigned idx_of_first_zero_bit(uint32_t n) {
  int idx = 0;
  if (n == 0xffffffff) return 32;  // Not found; presumably the common case

  // Binary search
  if (n & 0xffff == 0xffff) {
    n >>= 16;
    idx += 16;
  }
  if (n & 0xff == 0xff) {
    n >>= 8;
    idx += 8;
  }
  if (n & 0xf == 0xf) {
    n >>= 4;
    idx += 4;
  }
  if (n & 0x3 == 0x3) {
    n >>= 2;
    idx += 2;
  }
  if (n & 0x1 == 0x1) {
    n >>= 1;
    idx += 1;
  }
  return idx;
}

分岐の予測ミスを回避するために、ビットごとの操作で条件付き更新を行うことができます。

int shift;

// First step
shift = ((n & 0xffff == 0xffff) << 4); // shift = (n & 0xffff == 0xffff) ? 16 : 0
n >>= shift;
idx += shift;

// Next step
shift = ((n & 0xff == 0xff) << 3); // shift = (n & 0xff == 0xff) ? 8 : 0
n >>= shift;
idx += shift;