จะนับจำนวนบิตที่ตั้งค่าเป็นจำนวนเต็ม 32 บิตได้อย่างไร?

8 บิตที่เป็นตัวแทนของหมายเลข 7 มีลักษณะดังนี้:

00000111

ตั้งสามบิต

อัลกอริทึมในการกำหนดจำนวนบิตที่ตั้งไว้ในจำนวนเต็ม 32- บิตคืออะไร?

สิ่งนี้เรียกว่า ' Hamming Weight ', 'popcount' หรือ 'การเพิ่มด้านข้าง'

อัลกอริทึม 'ดีที่สุด' ขึ้นอยู่กับ CPU ของคุณและรูปแบบการใช้งานของคุณ

ซีพียูบางตัวมีคำสั่งในตัวเดียวที่ต้องทำและบางตัวก็มีคำสั่งแบบขนานซึ่งทำหน้าที่เป็นเวกเตอร์บิต คำแนะนำแบบขนาน (เช่น x86 popcntบนซีพียูที่รองรับ) เกือบจะเร็วที่สุดแน่นอน สถาปัตยกรรมอื่น ๆ บางแห่งอาจมีคำสั่งที่ช้าซึ่งนำมาใช้กับลูป microcoded ที่ทดสอบบิตต่อรอบ ( อ้างอิงที่จำเป็น )

วิธีการค้นหาตารางที่เติมไว้ล่วงหน้าสามารถทำได้อย่างรวดเร็วหาก CPU ของคุณมีแคชขนาดใหญ่และ / หรือคุณกำลังทำตามคำแนะนำเหล่านี้จำนวนมากในการวนรอบที่แน่น อย่างไรก็ตามอาจมีปัญหาเนื่องจากค่าใช้จ่ายของ 'cache miss' ซึ่ง CPU ต้องดึงข้อมูลบางส่วนจากหน่วยความจำหลัก (ค้นหาแต่ละไบต์แยกกันเพื่อทำให้โต๊ะเล็ก)

หากคุณรู้ว่าไบต์ของคุณจะเป็นส่วนใหญ่ 0 หรือส่วนใหญ่ 1 แล้วมีอัลกอริทึมที่มีประสิทธิภาพมากสำหรับสถานการณ์เหล่านี้

ฉันเชื่อว่าอัลกอริทึมสำหรับวัตถุประสงค์ทั่วไปที่ดีมากมีดังต่อไปนี้เรียกว่า 'ขนาน' หรือ 'อัลกอริทึม SWAR ที่มีความแม่นยำของตัวแปร' ฉันได้แสดงสิ่งนี้ในภาษาหลอกซีเช่นคุณอาจต้องปรับให้ทำงานสำหรับภาษาเฉพาะ (เช่นใช้ uint32_t สำหรับ C ++ และ >>> ใน Java):

int numberOfSetBits(uint32_t i)
{
     // Java: use int, and use >>> instead of >>
     // C or C++: use uint32_t
     i = i - ((i >> 1) & 0x55555555);
     i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
     return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
}

สำหรับ JavaScript: บังคับให้เป็นจำนวนเต็มด้วย|0สำหรับประสิทธิภาพ: เปลี่ยนบรรทัดแรกเป็นi = (i|0) - ((i >> 1) & 0x55555555);

นี่เป็นพฤติกรรมที่เลวร้ายที่สุดที่ดีที่สุดของอัลกอริทึมใด ๆ ที่กล่าวถึงดังนั้นจะจัดการกับรูปแบบการใช้งานหรือค่าที่คุณขว้างได้อย่างมีประสิทธิภาพ

วิธีการทำงานของ SWAR Bithack นี้:

i = i - ((i >> 1) & 0x55555555);

ขั้นตอนแรกคือเวอร์ชั่นที่เหมาะที่สุดของการปิดบังเพื่อแยกบิตคี่ / คู่ให้เลื่อนไปตามแถวและเพิ่ม สิ่งนี้จะทำการแยก 16 ส่วนเพิ่มเติมในตัวสะสมแบบ 2 บิต ( SWAR = SIMD ภายในการลงทะเบียน ) กด(i & 0x55555555) + ((i>>1) & 0x55555555)ไลค์

ขั้นตอนถัดไปใช้เวลาคี่ / คู่แปดเท่าของตัวสะสม 16x2 บิตเหล่านั้นและเพิ่มอีกครั้งโดยสร้างผลรวม 8x 4 บิต การi - ...เพิ่มประสิทธิภาพไม่สามารถทำได้ในครั้งนี้ดังนั้นจึงเป็นเพียงหน้ากากก่อน / หลังการเปลี่ยน ใช้0x33...ค่าคงที่เดียวกันทั้งสองครั้งแทน0xccc...ก่อนการเปลี่ยนเป็นสิ่งที่ดีเมื่อรวบรวม ISAs ที่จำเป็นต้องสร้างค่าคงที่แบบ 32 บิตในการลงทะเบียนแยกต่างหาก

ขั้นตอนสุดท้ายของการเลื่อนและเพิ่มความ(i + (i >> 4)) & 0x0F0F0F0Fกว้างเป็น 4x8 บิตสะสม มันมาสก์หลังจากเพิ่มแทนก่อนเพราะค่าสูงสุดในการสะสม 4 บิตใด ๆ คือ4ถ้าทั้ง 4 บิตของบิตที่สอดคล้องกันถูกตั้งค่า 4 + 4 = 8 ซึ่งยังคงเหมาะกับใน 4 i + (i >> 4)บิตเพื่อให้การดำเนินการระหว่างองค์ประกอบตอดเป็นไปไม่ได้ใน

จนถึงตอนนี้เป็นเพียงปกติ SIMD โดยใช้เทคนิค SWAR ด้วยการเพิ่มประสิทธิภาพที่ชาญฉลาด การดำเนินการต่อด้วยรูปแบบเดียวกันอีก 2 ขั้นตอนสามารถขยายเป็น 2x16- บิตแล้วนับ 1x 32- บิต แต่มีวิธีที่มีประสิทธิภาพมากขึ้นในเครื่องที่มีฮาร์ดแวร์ที่รวดเร็วคูณ:

เมื่อเรามีไม่กี่พอ "องค์ประกอบ" คูณด้วยค่าคงมายากลสามารถรวมองค์ประกอบทั้งหมดลงในองค์ประกอบด้านบน ในกรณีนี้องค์ประกอบไบต์ คูณจะกระทำโดยซ้ายขยับและการเพิ่มดังนั้นคูณของผลในการx * 0x01010101 x + (x<<8) + (x<<16) + (x<<24) อิลิเมนต์ 8 บิตของเรานั้นกว้างพอ (และถือจำนวนที่น้อยพอ) ซึ่งสิ่งนี้ไม่ได้ส่งไปยัง 8 บิตสูงสุด

รุ่น 64 บิตนี้สามารถทำ 8x องค์ประกอบ 8 บิตในจำนวนเต็ม 64 บิตกับ 0x0101010101010101 >>56คูณและสารสกัดจากไบต์สูงด้วย ดังนั้นจึงไม่ทำตามขั้นตอนพิเศษใด ๆ เพียงแค่ค่าคงที่ที่กว้างขึ้น นี่คือสิ่งที่ GCC ใช้สำหรับ__builtin_popcountllระบบ x86 เมื่อpopcntไม่ได้เปิดใช้งานคำสั่งฮาร์ดแวร์ หากคุณสามารถใช้ builtins หรือ intrinsics สำหรับสิ่งนี้ให้เปิดโอกาสให้คอมไพเลอร์มีโอกาสทำการปรับแต่งเฉพาะเป้าหมาย

ด้วย SIMD แบบเต็มสำหรับเวกเตอร์ที่กว้างขึ้น (เช่นการนับอาร์เรย์ทั้งหมด)

อัลกอริธึม bitwise-SWAR นี้สามารถทำขนานกันได้ในองค์ประกอบเวกเตอร์หลายรายการพร้อมกันแทนการลงทะเบียนเลขจำนวนเต็มเดียวเพื่อเพิ่มความเร็วของ CPU ที่มี SIMD แต่ไม่มีคำสั่ง popcount ที่ใช้งานได้ (เช่นรหัส x86-64 ที่ต้องรันบน CPU ใด ๆ ไม่ใช่เฉพาะ Nehalem หรือใหม่กว่า)

อย่างไรก็ตามวิธีที่ดีที่สุดในการใช้คำแนะนำแบบเวกเตอร์สำหรับ popcount คือโดยใช้ตัวแปรแบบสุ่มเพื่อทำการค้นหาแบบตารางสำหรับ 4 บิตในแต่ละครั้งของแต่ละไบต์แบบขนาน (ดัชนี 4 บิตรายการตาราง 16 ที่จัดขึ้นในการลงทะเบียนแบบเวกเตอร์)

บน CPU ของ Intel, การเรียนการสอนฮาร์ดแวร์ 64bit popcnt สามารถ outperform SSSE3 PSHUFBบิตขนานการดำเนินงานโดยเกี่ยวกับปัจจัย 2 แต่ถ้าคอมไพเลอร์ของคุณได้รับมันเพียงขวา มิฉะนั้น SSE จะออกมาข้างหน้าอย่างมีนัยสำคัญ เวอร์ชั่นคอมไพเลอร์รุ่นใหม่จะรับรู้ถึงปัญหาการพึ่งพา popcnt false ใน Intelปัญหาเกี่ยวกับอินเทล

อ้างอิง:

• https://graphics.stanford.edu/~seander/bithacks.html
• https://en.wikipedia.org/wiki/Hamming_weight
• http://gurmeet.net/puzzles/fast-bit-counting-routines/
• http://aggregate.ee.engr.uky.edu/MAGIC/#Population%20Count%20(Ones%20Count)

พิจารณาฟังก์ชั่นในตัวของคอมไพเลอร์ของคุณด้วย

ในคอมไพเลอร์ GNU เช่นคุณสามารถใช้:

int __builtin_popcount (unsigned int x);
int __builtin_popcountll (unsigned long long x);

ในกรณีที่เลวร้ายที่สุดคอมไพเลอร์จะสร้างการเรียกไปยังฟังก์ชัน ในกรณีที่ดีที่สุดคอมไพเลอร์จะส่งคำสั่ง cpu ให้ทำงานเร็วขึ้น

Intrinsics ของ GCC สามารถใช้งานได้กับหลายแพลตฟอร์ม Popcount จะกลายเป็นกระแสหลักในสถาปัตยกรรม x86 ดังนั้นจึงเป็นเรื่องเหมาะสมที่จะเริ่มใช้อินทรินในตอนนี้ สถาปัตยกรรมอื่น ๆ มี popcount มานานหลายปี

บน x86 คุณสามารถบอกคอมไพเลอร์ว่าสามารถรองรับการpopcntเรียนการสอนด้วย-mpopcntหรือ-msse4.2เพื่อเปิดใช้งานคำแนะนำเวกเตอร์ที่เพิ่มเข้ามาในรุ่นเดียวกัน ดูตัวเลือก x86 GCC -march=nehalem(หรือ-march=ซีพียูอะไรก็ตามที่คุณต้องการให้โค้ดของคุณสมมติและปรับแต่ง) อาจเป็นตัวเลือกที่ดี การเรียกใช้ไบนารีที่เกิดขึ้นบน CPU ตัวเก่าจะส่งผลให้เกิดความผิดปกติในการสอน

ในการทำให้ไบนารีปรับให้เหมาะสมสำหรับเครื่องที่คุณสร้างให้ใช้-march=native (ด้วย gcc, clang หรือ ICC)

MSVC ให้popcntคำแนะนำที่แท้จริงสำหรับคำสั่งx86แต่ต่างจาก gcc ซึ่งเป็นคำแนะนำที่แท้จริงสำหรับคำสั่งฮาร์ดแวร์และต้องการการสนับสนุนฮาร์ดแวร์

ใช้std::bitset<>::count()แทนการติดตั้งในตัว

ในทางทฤษฎีคอมไพเลอร์ใด ๆ ที่รู้วิธีการ popcount ได้อย่างมีประสิทธิภาพสำหรับ CPU เป้าหมายควรเปิดเผยการทำงานที่ผ่านการรับรองมาตรฐาน ISO C std::bitset<>++ ในทางปฏิบัติคุณอาจจะดีกว่าด้วยบิตแฮ็คและ / shift / ADD ในบางกรณีสำหรับซีพียูเป้าหมายบางตัว

สำหรับสถาปัตยกรรมเป้าหมายที่ป็อปอัพฮาร์ดแวร์เป็นส่วนเสริมเพิ่มเติม (เช่น x86) คอมไพเลอร์บางตัวstd::bitsetจะมีข้อดีที่ใช้เมื่อมี ตัวอย่างเช่น MSVC ไม่มีวิธีที่จะเปิดใช้งานpopcntการสนับสนุนในเวลารวบรวมและมักจะใช้การค้นหาตารางแม้จะมี/Ox /arch:AVX(ซึ่งหมายถึง SSE4.2 แม้ว่าในทางเทคนิคจะมีบิตคุณลักษณะแยกต่างหากสำหรับpopcnt)

แต่อย่างน้อยคุณก็มีอุปกรณ์พกพาที่ใช้งานได้ทุกที่และด้วย gcc / clang ด้วยตัวเลือกเป้าหมายที่ถูกต้องคุณจะได้รับ popcount ฮาร์ดแวร์สำหรับสถาปัตยกรรมที่รองรับ

#include <bitset>
#include <limits>
#include <type_traits>

template<typename T>
//static inline  // static if you want to compile with -mpopcnt in one compilation unit but not others
typename std::enable_if<std::is_integral<T>::value,  unsigned >::type 
popcount(T x)
{
    static_assert(std::numeric_limits<T>::radix == 2, "non-binary type");

    // sizeof(x)*CHAR_BIT
    constexpr int bitwidth = std::numeric_limits<T>::digits + std::numeric_limits<T>::is_signed;
    // std::bitset constructor was only unsigned long before C++11.  Beware if porting to C++03
    static_assert(bitwidth <= std::numeric_limits<unsigned long long>::digits, "arg too wide for std::bitset() constructor");

    typedef typename std::make_unsigned<T>::type UT;        // probably not needed, bitset width chops after sign-extension

    std::bitset<bitwidth> bs( static_cast<UT>(x) );
    return bs.count();
}

ดูasm จาก gcc, clang, icc และ MSVCบนตัวรวบรวมคอมไพเลอร์ Godbolt

x86-64 gcc -O3 -std=gnu++11 -mpopcntปล่อยสิ่งนี้:

unsigned test_short(short a) { return popcount(a); }
    movzx   eax, di      # note zero-extension, not sign-extension
    popcnt  rax, rax
    ret
unsigned test_int(int a) { return popcount(a); }
    mov     eax, edi
    popcnt  rax, rax
    ret
unsigned test_u64(unsigned long long a) { return popcount(a); }
    xor     eax, eax     # gcc avoids false dependencies for Intel CPUs
    popcnt  rax, rdi
    ret

PowerPC64 gcc -O3 -std=gnu++11ส่งเสียง (สำหรับintรุ่น ARG):

    rldicl 3,3,0,32     # zero-extend from 32 to 64-bit
    popcntd 3,3         # popcount
    blr

แหล่งที่มานี้ไม่ได้เฉพาะ x86 หรือ GNU เฉพาะเลย แต่จะรวบรวมได้ดีสำหรับ x86 ด้วย gcc / clang / icc

นอกจากนี้โปรดทราบว่าการย้อนกลับของ gcc สำหรับสถาปัตยกรรมที่ไม่มี popcount คำสั่งเดียวคือการค้นหาตารางแบบไบต์ต่อครั้ง มันไม่ได้ยอดเยี่ยมสำหรับ ARM เช่นกัน

ในความคิดของฉันทางออกที่ดีที่สุดคือโซลูชันที่สามารถอ่านได้โดยโปรแกรมเมอร์คนอื่น (หรือโปรแกรมเมอร์ดั้งเดิมในอีกสองปีต่อมา) โดยไม่มีความคิดเห็นมากมาย คุณอาจต้องการโซลูชันที่เร็วที่สุดหรือฉลาดที่สุดซึ่งบางอันมีให้อยู่แล้ว แต่ฉันชอบความสามารถในการอ่านมากกว่าความฉลาดในเวลาใดก็ได้

unsigned int bitCount (unsigned int value) {
    unsigned int count = 0;
    while (value > 0) {           // until all bits are zero
        if ((value & 1) == 1)     // check lower bit
            count++;
        value >>= 1;              // shift bits, removing lower bit
    }
    return count;
}

หากคุณต้องการความเร็วมากขึ้น (และสมมติว่าคุณจัดทำเอกสารได้ดีเพื่อช่วยผู้สืบทอดตำแหน่งของคุณ) คุณสามารถใช้การค้นหาตาราง:

// Lookup table for fast calculation of bits set in 8-bit unsigned char.

static unsigned char oneBitsInUChar[] = {
//  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F (<- n)
//  =====================================================
    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, // 0n
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, // 1n
    : : :
    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8, // Fn
};

// Function for fast calculation of bits set in 16-bit unsigned short.

unsigned char oneBitsInUShort (unsigned short x) {
    return oneBitsInUChar [x >>    8]
         + oneBitsInUChar [x &  0xff];
}

// Function for fast calculation of bits set in 32-bit unsigned int.

unsigned char oneBitsInUInt (unsigned int x) {
    return oneBitsInUShort (x >>     16)
         + oneBitsInUShort (x &  0xffff);
}

แม้ว่าสิ่งเหล่านี้ขึ้นอยู่กับขนาดชนิดข้อมูลที่เฉพาะเจาะจงดังนั้นจึงไม่สามารถพกพาได้ แต่เนื่องจากการเพิ่มประสิทธิภาพประสิทธิภาพหลายอย่างยังไม่สามารถพกพาได้นั่นอาจไม่ใช่ปัญหา หากคุณต้องการความสะดวกในการพกพาฉันจะใช้วิธีแก้ปัญหาที่อ่านได้

จากความยินดีของแฮกเกอร์หน้า 66, รูปที่ 5-2

int pop(unsigned x)
{
    x = x - ((x >> 1) & 0x55555555);
    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
    x = (x + (x >> 4)) & 0x0F0F0F0F;
    x = x + (x >> 8);
    x = x + (x >> 16);
    return x & 0x0000003F;
}

ดำเนินการในคำแนะนำ ~ 20-ish (ขึ้นอยู่กับส่วนโค้ง) ไม่มีการแตกแขนง

ความสุขใจของแฮกเกอร์ นั้นน่ายินดี! แนะนำเป็นอย่างยิ่ง

ฉันคิดว่าวิธีที่เร็วที่สุด - โดยไม่ต้องใช้ตารางการค้นหาและpopcount - ต่อไปนี้ มันนับชุดบิตด้วยการดำเนินการเพียง 12

int popcount(int v) {
    v = v - ((v >> 1) & 0x55555555);                // put count of each 2 bits into those 2 bits
    v = (v & 0x33333333) + ((v >> 2) & 0x33333333); // put count of each 4 bits into those 4 bits  
    return c = ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}

มันใช้งานได้เพราะคุณสามารถนับจำนวนบิตทั้งหมดที่ตั้งไว้โดยแบ่งเป็นสองส่วนและนับจำนวนบิตที่ตั้งค่าในครึ่งทั้งสองแล้วเพิ่มขึ้น ยังรู้ว่าเป็นDivide and Conquerกระบวนทัศน์ มาลงรายละเอียดกันเถอะ ..

v = v - ((v >> 1) & 0x55555555); 

จำนวนบิตในสองบิตสามารถ0b00, หรือ0b01 0b10ลองทำสิ่งนี้กับ 2 บิต ..

 ---------------------------------------------
 |   v    |   (v >> 1) & 0b0101   |  v - x   |
 ---------------------------------------------
   0b00           0b00               0b00   
   0b01           0b00               0b01     
   0b10           0b01               0b01
   0b11           0b01               0b10

นี่คือสิ่งที่จำเป็น: คอลัมน์สุดท้ายแสดงจำนวนบิตที่ตั้งค่าในทุก ๆ สองบิต หากจำนวนสองบิต>= 2 (0b10)แล้วandผลิตอื่นมันผลิต0b010b00

v = (v & 0x33333333) + ((v >> 2) & 0x33333333); 

ข้อความนี้ควรเข้าใจง่าย หลังจากการดำเนินการครั้งแรกเรามีจำนวนบิตที่ตั้งค่าในทุก ๆ สองบิตตอนนี้เราจะสรุปจำนวนนั้นในทุกๆ 4 บิต

v & 0b00110011         //masks out even two bits
(v >> 2) & 0b00110011  // masks out odd two bits

จากนั้นเราจะสรุปผลลัพธ์ข้างต้นทำให้เรานับจำนวนบิตทั้งหมดใน 4 บิต คำสั่งสุดท้ายเป็นเรื่องที่ยุ่งยากที่สุด

c = ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;

มาทำลายมันกันต่อไป ...

v + (v >> 4)

มันคล้ายกับคำสั่งที่สอง; เรากำลังนับบิตตั้งเป็นกลุ่ม 4 แทน เรารู้ว่า - เนื่องจากการดำเนินการก่อนหน้าของเรา - ที่ทุก ๆ nibble มีจำนวนบิตที่ตั้งไว้ ลองดูตัวอย่าง 0b01000010สมมติว่าเรามีไบต์ มันหมายความว่าตอดแรกมีชุด 4 บิตและอันที่สองมีชุด 2 บิต ตอนนี้เราเพิ่ม nibbles เหล่านั้นเข้าด้วยกัน

0b01000010 + 0b01000000

มันทำให้เรานับจำนวนบิตที่ตั้งไว้ในไบต์ในแทะแรก0b01100010และดังนั้นเราจึงปกปิดสี่ไบต์สุดท้ายของไบต์ทั้งหมดในจำนวน (ละทิ้ง)

0b01100010 & 0xF0 = 0b01100000

ตอนนี้ทุกไบต์มีจำนวนบิตที่ตั้งไว้ เราต้องรวมทั้งหมดเข้าด้วยกัน เคล็ดลับคือการคูณผลลัพธ์ด้วย0b10101010คุณสมบัติที่น่าสนใจ ถ้าจำนวนของเรามีสี่ไบต์มันจะส่งผลให้ในจำนวนใหม่ที่มีไบต์เหล่านี้A B C D A+B+C+D B+C+D C+D Dหมายเลข 4 ไบต์สามารถตั้งค่าได้สูงสุด 32 บิตซึ่งสามารถแทน0b00100000ได้

>> 24ทั้งหมดที่เราต้องการตอนนี้คือไบต์แรกซึ่งมีผลรวมของทุกบิตชุดไบต์ทั้งหมดและเราได้รับมันโดย อัลกอริทึมนี้ถูกออกแบบมาสำหรับ32 bitคำ แต่สามารถแก้ไขได้ง่ายสำหรับ64 bitคำ

ฉันเบื่อและตั้งเวลาซ้ำสามพันล้านครั้งในสามวิธี คอมไพเลอร์คือ gcc -O3 CPU คือสิ่งที่พวกเขาใส่ใน Macbook Pro รุ่นที่ 1

เร็วที่สุดคือต่อไปนี้ที่ 3.7 วินาที:

static unsigned char wordbits[65536] = { bitcounts of ints between 0 and 65535 };
static int popcount( unsigned int i )
{
    return( wordbits[i&0xFFFF] + wordbits[i>>16] );
}

อันดับที่สองไปที่รหัสเดียวกัน แต่ค้นหา 4 ไบต์แทน 2 halfwords ใช้เวลาประมาณ 5.5 วินาที

อันดับที่สามใช้แนวทาง 'การเพิ่มด้านข้าง' ซึ่งใช้เวลา 8.6 วินาที

อันดับที่สี่ไปที่ __builtin_popcount () ของ GCC ในเวลา 11 วินาทีที่น่าอับอาย

การนับหนึ่งครั้งต่อครั้งช้ากว่าและฉันเบื่อที่จะรอให้เสร็จ

ดังนั้นหากคุณใส่ใจกับประสิทธิภาพเหนือสิ่งอื่นใดให้ใช้วิธีแรก หากคุณสนใจ แต่ไม่เพียงพอที่จะใช้ RAM ขนาด 64Kb ให้ใช้วิธีที่สอง มิฉะนั้นให้ใช้วิธีอ่านแบบทีละครั้ง (แต่ช้า)

มันยากที่จะคิดว่าสถานการณ์ที่คุณต้องการใช้วิธีการทวิ - ทวิ

แก้ไข: ผลลัพธ์ที่คล้ายกันที่นี่

หากคุณบังเอิญใช้จาวาวิธีการในตัวInteger.bitCountจะทำเช่นนั้น

unsigned int count_bit(unsigned int x)
{
  x = (x & 0x55555555) + ((x >> 1) & 0x55555555);
  x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
  x = (x & 0x0F0F0F0F) + ((x >> 4) & 0x0F0F0F0F);
  x = (x & 0x00FF00FF) + ((x >> 8) & 0x00FF00FF);
  x = (x & 0x0000FFFF) + ((x >> 16)& 0x0000FFFF);
  return x;
}

ให้ฉันอธิบายอัลกอริทึมนี้

อัลกอริทึมนี้ขึ้นอยู่กับอัลกอริทึมหารและพิชิต สมมติว่ามีจำนวนเต็ม 8 บิต 213 (11010101 ในไบนารี) อัลกอริทึมทำงานเช่นนี้ (แต่ละครั้งรวมสองบล็อกเพื่อนบ้าน):

+-------------------------------+
| 1 | 1 | 0 | 1 | 0 | 1 | 0 | 1 |  <- x
|  1 0  |  0 1  |  0 1  |  0 1  |  <- first time merge
|    0 0 1 1    |    0 0 1 0    |  <- second time merge
|        0 0 0 0 0 1 0 1        |  <- third time ( answer = 00000101 = 5)
+-------------------------------+

นี่เป็นหนึ่งในคำถามที่ช่วยให้รู้จักสถาปัตยกรรมไมโครของคุณ ฉันเพิ่งตั้งเวลาตัวแปรสองตัวภายใต้ gcc 4.3.3 ที่คอมไพล์ด้วย -O3 โดยใช้อินไลน์ C ++ เพื่อกำจัดโอเวอร์เฮดการเรียกใช้ฟังก์ชันหนึ่งพันล้านซ้ำการรักษาผลรวมการทำงานของจำนวนทั้งหมดเพื่อให้แน่ใจว่าคอมไพเลอร์ไม่ได้เอาสิ่งใดสำคัญออก รอบนาฬิกาแม่นยำ)

อินไลน์ int pop2 (x ที่ไม่ได้ลงชื่อ, y ที่ไม่ได้ลงชื่อ)
{
    x = x - ((x >> 1) & 0x55555555);
    y = y - ((y >> 1) & 0x55555555);
    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
    y = (y & 0x33333333) + ((y >> 2) & 0x33333333);
    x = (x + (x >> 4)) & 0x0F0F0F0F;
    y = (y + (y >> 4)) & 0x0F0F0F0F;
    x = x + (x >> 8);
    y = y + (y >> 8);
    x = x + (x >> 16);
    y = y + (y >> 16);
    ส่งคืน (x + y) & 0x000000FF;
}

Delight ของแฮ็กเกอร์ที่ไม่ได้แก้ไขนั้นใช้เวลา 12.2 กิกะบิต รุ่นคู่ขนานของฉัน (นับเป็นสองเท่าของจำนวนบิต) ทำงานใน 13.0 กิกะบิต 10.5 วินาทีที่ผ่านมารวมกันสำหรับทั้งคู่ใน 2.4GHz Core Duo 25 gigacycles = เพียง 10 วินาทีที่ความถี่สัญญาณนาฬิกาดังนั้นฉันมั่นใจว่าเวลาของฉันถูกต้องแล้ว

สิ่งนี้เกี่ยวข้องกับกลุ่มพึ่งพาการเรียนการสอนซึ่งไม่ดีสำหรับอัลกอริทึมนี้ ฉันสามารถเพิ่มความเร็วเป็นสองเท่าได้อีกครั้งด้วยการลงทะเบียน 64 บิต ในความเป็นจริงถ้าฉันฉลาดและเพิ่ม x + ya เร็ว ๆ นี้ฉันจะสามารถกำจัดการเปลี่ยนแปลงบางอย่างได้ รุ่น 64 บิตที่มีการปรับแต่งเล็กน้อยจะออกมาเท่า ๆ กัน แต่นับเป็นสองเท่าเป็นจำนวนมากอีกครั้ง

ด้วยการลงทะเบียน SIMD ขนาด 128 บิต แต่เป็นอีกปัจจัยที่สองและชุดคำสั่ง SSE มักจะมีทางลัดที่ฉลาดเช่นกัน

ไม่มีเหตุผลใดที่รหัสจะโปร่งใสโดยเฉพาะ อินเทอร์เฟซนั้นง่ายอัลกอริทึมสามารถอ้างอิงออนไลน์ในหลาย ๆ สถานที่และสามารถตอบสนองต่อการทดสอบหน่วยที่ครอบคลุม โปรแกรมเมอร์ที่สะดุดเมื่อมันอาจเรียนรู้บางสิ่งบางอย่าง การทำงานของบิตเหล่านี้เป็นเรื่องธรรมดามากในระดับเครื่อง

ตกลงฉันตัดสินใจที่จะพิพากษาเวอร์ชัน 64 บิตที่ได้รับการปรับแต่ง สำหรับขนาดนี้ (ยาวไม่ได้ลงนาม) == 8

inline int pop2 (ยาวไม่ลงนาม x, ไม่ได้ลงนามยาว y)
{
    x = x - ((x >> 1) & 0x5555555555555555);
    y = y - ((y >> 1) & 0x5555555555555555);
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333);
    y = (y & 0x33333333333333) + ((y >> 2) & 0x33333333333333)
    x = (x + (x >> 4)) & 0x0F0F0F0F0F0F0F0F0F;
    y = (y + (y >> 4)) & 0x0F0F0F0F0F0F0F0F0F;
    x = x + y; 
    x = x + (x >> 8);
    x = x + (x >> 16);
    x = x + (x >> 32); 
    ส่งคืน x & 0xFF;
}

ดูเหมือนว่าถูกต้อง (ฉันไม่ได้ทดสอบอย่างรอบคอบ) ตอนนี้เวลาออกมาที่ 10.70 gigacycles / 14.1 gigacycles หมายเลขนั้นในภายหลังนั้นรวม 128 พันล้านบิตและสอดคล้องกับ 5.9 วินาทีที่ผ่านไปในเครื่องนี้ รุ่นที่ไม่ขนานกันเร็วขึ้นเล็กน้อยเพราะฉันทำงานในโหมด 64 บิตและชอบการลงทะเบียน 64 บิตดีกว่าการลงทะเบียน 32 บิตเล็กน้อย

เรามาดูกันว่ามีการวางท่อ OOO อีกเล็กน้อยที่นี่หรือไม่ นี่เกี่ยวข้องกับอีกเล็กน้อยดังนั้นฉันจึงทดสอบจริง ๆ เล็กน้อย แต่ละเทอมรวมอยู่ที่ 64 รวมทั้งหมดเป็น 256

inline int pop4 (ยาวไม่ลงนาม x, ไม่ได้ลงนามยาว y, 
                ไม่ได้ลงนามยาวคุณ v ไม่ลงนามยาว)
{
  enum {m1 = 0x5555555555555555 
         m2 = 0x3333333333333333, 
         m3 = 0x0F0F0F0F0F0F0F0F0F, 
         m4 = 0x000000FF000000FF};

    x = x - ((x >> 1) & m1);
    y = y - ((y >> 1) & m1);
    u = u - ((u >> 1) & m1);
    v = v - ((v >> 1) & m1);
    x = (x & m2) + ((x >> 2) & m2);
    y = (y & m2) + ((y >> 2) & m2);
    u = (u & m2) + ((u >> 2) & m2);
    v = (v & m2) + ((v >> 2) & m2);
    x = x + y; 
    u = u + v; 
    x = (x & m3) + ((x >> 4) & m3);
    u = (u & m3) + ((u >> 4) & m3);
    x = x + u; 
    x = x + (x >> 8);
    x = x + (x >> 16);
    x = x & m4; 
    x = x + (x >> 32);
    ส่งคืน x & 0x000001FF;
}

ฉันตื่นเต้นสักครู่ แต่ปรากฎว่า gcc กำลังเล่นเทคนิคแบบอินไลน์ด้วย -O3 แม้ว่าฉันไม่ได้ใช้คำหลักแบบอินไลน์ในการทดสอบบางอย่าง เมื่อฉันให้ gcc play tricks หนึ่งพันล้านการเรียกไปยัง pop4 () ใช้เวลา 12.56 gigacycles แต่ฉันคิดว่ามันเป็นอาร์กิวเมนต์การพับเป็นนิพจน์คงที่ จำนวนที่เหมือนจริงมากขึ้นดูเหมือนจะเป็น 19.6gc สำหรับความเร็วอีก 30% ตอนนี้ลูปทดสอบของฉันมีลักษณะเช่นนี้ตรวจสอบให้แน่ใจว่าแต่ละอาร์กิวเมนต์แตกต่างกันพอที่จะหยุด gcc ไม่ให้เล่นกล

   hitime b4 = rdtsc (); 
   สำหรับ (ความยาวที่ไม่ได้ลงชื่อ i = 10L * 1000 * 1000 * 1000; i <11L * 1000 * 1000 * 1000 * 1000 i ++) 
      sum + = pop4 (i, i ^ 1, ~ i, i | 1); 
   hitime e4 = rdtsc (); 

256,000 ล้านบิตรวมกันใน 8.17s ที่ผ่านไป ทำงานได้ถึง 1.02 วินาทีสำหรับ 32 ล้านบิตตามมาตรฐานในการค้นหาตาราง 16 บิต ไม่สามารถเปรียบเทียบได้โดยตรงเนื่องจากม้านั่งตัวอื่นไม่ให้ความเร็วสัญญาณนาฬิกา แต่ดูเหมือนว่าฉันตบน้ำมูกออกจากตารางรุ่น 64KB ซึ่งเป็นการใช้ L1 แคชที่น่าเศร้าในตอนแรก

อัปเดต: ตัดสินใจที่จะทำอย่างชัดเจนและสร้าง pop6 () โดยเพิ่มบรรทัดที่ซ้ำกันอีกสี่บรรทัด ออกมาที่ 22.8gc, 384 พันล้านบิตรวมกันใน 9.5 วินาทีที่ผ่านไป มีอีก 20% ตอนนี้ที่ 800 มิลลิวินาทีสำหรับ 32 พันล้านบิต

ทำไมไม่หาร 2 ซ้ำ ๆ กัน?

count = 0
ในขณะที่ n> 0
  if (n% 2) == 1
    นับ + = 1
  n / = 2  

ฉันยอมรับว่านี่ไม่ใช่วิธีที่เร็วที่สุด แต่ "ดีที่สุด" นั้นค่อนข้างคลุมเครือ ฉันขอยืนยันว่า "ดีที่สุด" ควรมีองค์ประกอบของความชัดเจน

Bit-Twiddling ของ Delight นั้นชัดเจนมากขึ้นเมื่อคุณเขียนรูปแบบบิต

unsigned int bitCount(unsigned int x)
{
  x = ((x >> 1) & 0b01010101010101010101010101010101)
     + (x       & 0b01010101010101010101010101010101);
  x = ((x >> 2) & 0b00110011001100110011001100110011)
     + (x       & 0b00110011001100110011001100110011); 
  x = ((x >> 4) & 0b00001111000011110000111100001111)
     + (x       & 0b00001111000011110000111100001111); 
  x = ((x >> 8) & 0b00000000111111110000000011111111)
     + (x       & 0b00000000111111110000000011111111); 
  x = ((x >> 16)& 0b00000000000000001111111111111111)
     + (x       & 0b00000000000000001111111111111111); 
  return x;
}

ขั้นตอนแรกเพิ่มบิตคู่ให้เป็นบิตคี่ทำให้เกิดผลรวมของบิตในแต่ละสอง ขั้นตอนอื่น ๆ เพิ่มชิ้นลำดับสูงไปยังชิ้นลำดับต่ำเพิ่มขนาดชิ้นสองเท่าจนสุดจนกว่าเราจะมีการนับขั้นสุดท้ายรับทั้ง int

สำหรับสื่อที่มีความสุขระหว่างตารางการค้นหา2 ³²และการวนซ้ำแต่ละบิต:

int bitcount(unsigned int num){
    int count = 0;
    static int nibblebits[] =
        {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
    for(; num != 0; num >>= 4)
        count += nibblebits[num & 0x0f];
    return count;
}

จากhttp://ctips.pbwiki.com/CountBits

สิ่งนี้สามารถทำได้ในO(k)ซึ่งkเป็นจำนวนบิตตั้ง

int NumberOfSetBits(int n)
{
    int count = 0;

    while (n){
        ++ count;
        n = (n - 1) & n;
    }

    return count;
}

ไม่ใช่วิธีที่เร็วหรือดีที่สุด แต่ฉันพบคำถามเดียวกันในแบบของฉันและฉันก็เริ่มคิดและคิด ในที่สุดฉันก็รู้ว่ามันสามารถทำได้เช่นนี้หากคุณได้รับปัญหาจากทางคณิตศาสตร์และวาดกราฟจากนั้นคุณจะพบว่ามันเป็นฟังก์ชันที่มีส่วนเป็นส่วน ๆ แล้วคุณก็จะเห็นความแตกต่างระหว่างจุด ... ไปเลย:

unsigned int f(unsigned int x)
{
    switch (x) {
        case 0:
            return 0;
        case 1:
            return 1;
        case 2:
            return 1;
        case 3:
            return 2;
        default:
            return f(x/4) + f(x%4);
    }
}

ฟังก์ชั่นที่คุณกำลังค้นหามักเรียกว่า "ผลรวมด้านข้าง" หรือ "จำนวนประชากร" ของเลขฐานสอง Knuth กล่าวถึงใน Pre-Fascicle 1A, pp11-12 (แม้ว่าจะมีการอ้างอิงสั้น ๆ ในเล่ม 2, 4.6.3- (7))

classicus สถานทีเป็นบทความปีเตอร์เวกเนอร์ของ "เทคนิคสำหรับคนนับในไบนารีคอมพิวเตอร์ A" จากการสื่อสารของพลอากาศเอกเล่ม 3 (1960) จํานวน 5, หน้า 322 เขาให้อัลกอริธึมที่ต่างกันสองอันหนึ่งอันเหมาะสำหรับตัวเลขที่คาดว่าจะ "กระจัดกระจาย" (กล่าวคือมีจำนวนน้อย) และอีกอันสำหรับกรณีตรงกันข้าม

  private int get_bits_set(int v)
    {
      int c; // c accumulates the total bits set in v
        for (c = 0; v>0; c++)
        {
            v &= v - 1; // clear the least significant bit set
        }
        return c;
    }

คำถามเปิดไม่กี่: -

1. ถ้าจำนวนเป็นลบล่ะ?
2. หากจำนวน 1024 วิธีการ "หารซ้ำด้วย 2" จะทำซ้ำ 10 ครั้ง

เราสามารถแก้ไข algo เพื่อรองรับจำนวนลบดังนี้: -

count = 0
while n != 0
if ((n % 2) == 1 || (n % 2) == -1
    count += 1
  n /= 2  
return count

ตอนนี้เพื่อเอาชนะปัญหาที่สองที่เราสามารถเขียนอัลโก้เช่น: -

int bit_count(int num)
{
    int count=0;
    while(num)
    {
        num=(num)&(num-1);
        count++;
    }
    return count;
}

สำหรับการอ้างอิงที่สมบูรณ์ดู:

http://goursaha.freeoda.com/Miscellaneous/IntegerBitCount.html

ฉันคิดว่าวิธีการของ Brian Kernighanจะมีประโยชน์เช่นกัน ... มันต้องผ่านการทำซ้ำหลายครั้งเมื่อมีการตั้งค่าบิต ดังนั้นถ้าเรามีคำ 32- บิตที่ตั้งค่าบิตสูงเท่านั้นมันจะผ่านวนรอบเพียงครั้งเดียว

int countSetBits(unsigned int n) { 
    unsigned int n; // count the number of bits set in n
    unsigned int c; // c accumulates the total bits set in n
    for (c=0;n>0;n=n&(n-1)) c++; 
    return c; 
}

ตีพิมพ์ในปี 1988 ภาษาโปรแกรม C ครั้งที่ 2 (โดย Brian W. Kernighan และ Dennis M. Ritchie) กล่าวถึงเรื่องนี้ในการออกกำลังกาย 2-9 ในวันที่ 19 เมษายน 2549 Don Knuth ชี้ให้ฉันเห็นว่าวิธีนี้ "ได้รับการตีพิมพ์ครั้งแรกโดย Peter Wegner ใน CACM 3 (1960), 322 (ค้นพบโดยอิสระจาก Derrick Lehmer และตีพิมพ์ในปี 1964 ในหนังสือที่แก้ไขโดย Beckenbach)"

ฉันใช้โค้ดด้านล่างซึ่งใช้งานง่ายกว่า

int countSetBits(int n) {
    return !n ? 0 : 1 + countSetBits(n & (n-1));
}

ลอจิก: n & (n-1) รีเซ็ตบิตสุดท้ายของ n

PS: ฉันรู้ว่านี่ไม่ใช่ทางออก O (1) แม้ว่าจะเป็นทางออกที่น่าสนใจ

คุณหมายความว่าอย่างไรกับ "อัลกอริทึมที่ดีที่สุด" รหัสย่อหรือรหัส fasted? รหัสของคุณดูดีมากและมีเวลาดำเนินการอย่างต่อเนื่อง รหัสนี้สั้นมาก

แต่ถ้าความเร็วเป็นปัจจัยสำคัญและไม่ใช่ขนาดรหัสฉันคิดว่าการติดตามจะเร็วขึ้น:

       static final int[] BIT_COUNT = { 0, 1, 1, ... 256 values with a bitsize of a byte ... };
        static int bitCountOfByte( int value ){
            return BIT_COUNT[ value & 0xFF ];
        }

        static int bitCountOfInt( int value ){
            return bitCountOfByte( value ) 
                 + bitCountOfByte( value >> 8 ) 
                 + bitCountOfByte( value >> 16 ) 
                 + bitCountOfByte( value >> 24 );
        }

ฉันคิดว่านี่จะไม่เร็วกว่าสำหรับค่า 64 บิต แต่ค่า 32 บิตนั้นเร็วขึ้น

ฉันเขียนมาโคร bitcount อย่างรวดเร็วสำหรับเครื่อง RISC ในประมาณปี 1990 มันไม่ได้ใช้เลขคณิตขั้นสูง (การคูณการหาร%) การดึงหน่วยความจำ (ทางช้าเกินไป) สาขา (ช้าเกินไป) แต่ถือว่า CPU มี ตัวเปลี่ยนบาร์เรลแบบ 32 บิต (กล่าวอีกนัยหนึ่ง >> 1 และ >> 32 ใช้จำนวนรอบเท่ากัน) ถือว่าค่าคงที่ขนาดเล็ก (เช่น 6, 12, 24) ไม่มีค่าใช้จ่ายใด ๆ ในการโหลดลงทะเบียนหรือถูกเก็บไว้ ในชั่วขณะและนำกลับมาใช้ซ้ำแล้วซ้ำอีก

ด้วยสมมติฐานเหล่านี้มันนับ 32 บิตในประมาณ 16 รอบ / คำสั่งในเครื่อง RISC ส่วนใหญ่ โปรดทราบว่า 15 คำแนะนำ / รอบใกล้กับขอบล่างของจำนวนรอบหรือคำสั่งเพราะดูเหมือนว่าจะใช้เวลาอย่างน้อย 3 คำแนะนำ (หน้ากาก, กะ, ผู้ประกอบการ) เพื่อลดจำนวนของการเพิ่มในครึ่งดังนั้น log_2 (32) = 5, 5 x 3 = 15 คำแนะนำคือกึ่งต่ำ

#define BitCount(X,Y)           \
                Y = X - ((X >> 1) & 033333333333) - ((X >> 2) & 011111111111); \
                Y = ((Y + (Y >> 3)) & 030707070707); \
                Y =  (Y + (Y >> 6)); \
                Y = (Y + (Y >> 12) + (Y >> 24)) & 077;

นี่เป็นความลับสำหรับขั้นตอนแรกและซับซ้อนที่สุด:

input output
AB    CD             Note
00    00             = AB
01    01             = AB
10    01             = AB - (A >> 1) & 0x1
11    10             = AB - (A >> 1) & 0x1

ดังนั้นถ้าฉันนำคอลัมน์ที่ 1 (A) ด้านบนเลื่อนไปทางขวา 1 บิตแล้วลบออกจาก AB ฉันจะได้ผลลัพธ์ (CD) ส่วนขยายถึง 3 บิตคล้ายกัน คุณสามารถตรวจสอบกับตารางบูลีน 8 แถวเหมือนของฉันด้านบนหากคุณต้องการ

• ดอนกิลลี

หากคุณใช้ C ++ ตัวเลือกอื่นคือการใช้ metaprogramming แม่แบบ:

// recursive template to sum bits in an int
template <int BITS>
int countBits(int val) {
        // return the least significant bit plus the result of calling ourselves with
        // .. the shifted value
        return (val & 0x1) + countBits<BITS-1>(val >> 1);
}

// template specialisation to terminate the recursion when there's only one bit left
template<>
int countBits<1>(int val) {
        return val & 0x1;
}

การใช้งานจะเป็น:

// to count bits in a byte/char (this returns 8)
countBits<8>( 255 )

// another byte (this returns 7)
countBits<8>( 254 )

// counting bits in a word/short (this returns 1)
countBits<16>( 256 )

แน่นอนว่าคุณสามารถขยายเทมเพลตนี้เพื่อใช้งานประเภทที่แตกต่างกัน (แม้กระทั่งการตรวจจับขนาดบิตอัตโนมัติ) แต่ฉันได้รักษาความเรียบง่ายไว้เพื่อความชัดเจน

แก้ไข: ลืมพูดถึงนี่เป็นสิ่งที่ดีเพราะมันควรจะทำงานในคอมไพเลอร์ C ++ ใด ๆ และมันเป็นเพียงแค่การวนรอบของคุณสำหรับคุณถ้าค่าคงที่จะใช้สำหรับการนับบิต (ในคำอื่น ๆ ฉันค่อนข้างแน่ใจว่ามันเป็นวิธีทั่วไปที่เร็วที่สุด คุณจะพบ)

ฉันชอบตัวอย่างนี้โดยเฉพาะจากไฟล์โชค:

#define BITCOUNT (x) ((BX_ (x) + (BX_ (x) >> 4)) & 0x0F0F0F0F0F)% 255)
#define BX_ (x) ((x) - ((x) >> 1) & 0x77777777)
                             - (((x) >> 2) & 0x33333333)
                             - (((x) >> 3) & 0x11111111))

ฉันชอบที่สุดเพราะมันสวยมาก!

Java JDK1.5

Integer.bitCount (n);

โดยที่ n คือหมายเลขที่จะนับ 1

ตรวจสอบด้วย

Integer.highestOneBit(n);
Integer.lowestOneBit(n);
Integer.numberOfLeadingZeros(n);
Integer.numberOfTrailingZeros(n);

//Beginning with the value 1, rotate left 16 times
     n = 1;
         for (int i = 0; i < 16; i++) {
            n = Integer.rotateLeft(n, 1);
            System.out.println(n);
         }

ฉันพบการใช้งานการนับบิตในอาร์เรย์ด้วยการใช้คำสั่ง SIMD (SSSE3 และ AVX2) มันมีประสิทธิภาพที่ดีขึ้นกว่า 2-2.5 เท่ากว่าถ้ามันจะใช้ __ popcnt64 ฟังก์ชั่นที่แท้จริง

รุ่น SSSE3:

#include <smmintrin.h>
#include <stdint.h>

const __m128i Z = _mm_set1_epi8(0x0);
const __m128i F = _mm_set1_epi8(0xF);
//Vector with pre-calculated bit count:
const __m128i T = _mm_setr_epi8(0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4);

uint64_t BitCount(const uint8_t * src, size_t size)
{
    __m128i _sum =  _mm128_setzero_si128();
    for (size_t i = 0; i < size; i += 16)
    {
        //load 16-byte vector
        __m128i _src = _mm_loadu_si128((__m128i*)(src + i));
        //get low 4 bit for every byte in vector
        __m128i lo = _mm_and_si128(_src, F);
        //sum precalculated value from T
        _sum = _mm_add_epi64(_sum, _mm_sad_epu8(Z, _mm_shuffle_epi8(T, lo)));
        //get high 4 bit for every byte in vector
        __m128i hi = _mm_and_si128(_mm_srli_epi16(_src, 4), F);
        //sum precalculated value from T
        _sum = _mm_add_epi64(_sum, _mm_sad_epu8(Z, _mm_shuffle_epi8(T, hi)));
    }
    uint64_t sum[2];
    _mm_storeu_si128((__m128i*)sum, _sum);
    return sum[0] + sum[1];
}

รุ่น AVX2:

#include <immintrin.h>
#include <stdint.h>

const __m256i Z = _mm256_set1_epi8(0x0);
const __m256i F = _mm256_set1_epi8(0xF);
//Vector with pre-calculated bit count:
const __m256i T = _mm256_setr_epi8(0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 
                                   0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4);

uint64_t BitCount(const uint8_t * src, size_t size)
{
    __m256i _sum =  _mm256_setzero_si256();
    for (size_t i = 0; i < size; i += 32)
    {
        //load 32-byte vector
        __m256i _src = _mm256_loadu_si256((__m256i*)(src + i));
        //get low 4 bit for every byte in vector
        __m256i lo = _mm256_and_si256(_src, F);
        //sum precalculated value from T
        _sum = _mm256_add_epi64(_sum, _mm256_sad_epu8(Z, _mm256_shuffle_epi8(T, lo)));
        //get high 4 bit for every byte in vector
        __m256i hi = _mm256_and_si256(_mm256_srli_epi16(_src, 4), F);
        //sum precalculated value from T
        _sum = _mm256_add_epi64(_sum, _mm256_sad_epu8(Z, _mm256_shuffle_epi8(T, hi)));
    }
    uint64_t sum[4];
    _mm256_storeu_si256((__m256i*)sum, _sum);
    return sum[0] + sum[1] + sum[2] + sum[3];
}

ฉันมักจะใช้สิ่งนี้ในการเขียนโปรแกรมการแข่งขันและง่ายต่อการเขียนและมีประสิทธิภาพ:

#include <bits/stdc++.h>

using namespace std;

int countOnes(int n) {
    bitset<32> b(n);
    return b.count();
}

มีอัลกอริทึมมากมายในการนับบิตตั้ง แต่ฉันคิดว่าดีที่สุดคือเร็วกว่า! คุณสามารถดูรายละเอียดในหน้านี้:

Bit Twiddling Hacks

ฉันแนะนำอันนี้:

การนับจำนวนบิตที่ตั้งค่าเป็น 14, 24 หรือ 32- บิตโดยใช้คำสั่ง 64- บิต

unsigned int v; // count the number of bits set in v
unsigned int c; // c accumulates the total bits set in v

// option 1, for at most 14-bit values in v:
c = (v * 0x200040008001ULL & 0x111111111111111ULL) % 0xf;

// option 2, for at most 24-bit values in v:
c =  ((v & 0xfff) * 0x1001001001001ULL & 0x84210842108421ULL) % 0x1f;
c += (((v & 0xfff000) >> 12) * 0x1001001001001ULL & 0x84210842108421ULL) 
     % 0x1f;

// option 3, for at most 32-bit values in v:
c =  ((v & 0xfff) * 0x1001001001001ULL & 0x84210842108421ULL) % 0x1f;
c += (((v & 0xfff000) >> 12) * 0x1001001001001ULL & 0x84210842108421ULL) % 
     0x1f;
c += ((v >> 24) * 0x1001001001001ULL & 0x84210842108421ULL) % 0x1f;

วิธีนี้ต้องใช้ CPU 64 บิตที่มีการแบ่งโมดูลัสอย่างรวดเร็วเพื่อให้มีประสิทธิภาพ ตัวเลือกแรกใช้เวลาเพียง 3 การดำเนินการ; ตัวเลือกที่สองใช้เวลา 10; และตัวเลือกที่สามใช้เวลา 15

วิธีแก้ปัญหา Fast C # โดยใช้ตารางที่คำนวณล่วงหน้าของจำนวนไบต์ที่มีการแยกย่อยตามขนาดอินพุต

public static class BitCount
{
    public static uint GetSetBitsCount(uint n)
    {
        var counts = BYTE_BIT_COUNTS;
        return n <= 0xff ? counts[n]
             : n <= 0xffff ? counts[n & 0xff] + counts[n >> 8]
             : n <= 0xffffff ? counts[n & 0xff] + counts[(n >> 8) & 0xff] + counts[(n >> 16) & 0xff]
             : counts[n & 0xff] + counts[(n >> 8) & 0xff] + counts[(n >> 16) & 0xff] + counts[(n >> 24) & 0xff];
    }

    public static readonly uint[] BYTE_BIT_COUNTS = 
    {
        0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
        4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
    };
}

นี่คือโมดูลพกพา (ANSI-C) ซึ่งสามารถวัดมาตรฐานของอัลกอริทึมของคุณในสถาปัตยกรรมใด ๆ

CPU ของคุณมีขนาด 9 บิตหรือไม่ ไม่มีปัญหา :-) ในขณะนี้ใช้ 2 อัลกอริทึม K&R อัลกอริทึมและตารางการค้นหาไบต์ที่ชาญฉลาด ตารางการค้นหานั้นเร็วกว่าอัลกอริทึม K&R โดยเฉลี่ย 3 เท่า หากใครบางคนสามารถหาวิธีที่จะทำให้อัลกอริทึม "แฮปปี้ดีไลท์" แบบพกพารู้สึกฟรีเพื่อเพิ่มมัน

#ifndef _BITCOUNT_H_
#define _BITCOUNT_H_

/* Return the Hamming Wieght of val, i.e. the number of 'on' bits. */
int bitcount( unsigned int );

/* List of available bitcount algorithms.  
 * onTheFly:    Calculate the bitcount on demand.
 *
 * lookupTalbe: Uses a small lookup table to determine the bitcount.  This
 * method is on average 3 times as fast as onTheFly, but incurs a small
 * upfront cost to initialize the lookup table on the first call.
 *
 * strategyCount is just a placeholder. 
 */
enum strategy { onTheFly, lookupTable, strategyCount };

/* String represenations of the algorithm names */
extern const char *strategyNames[];

/* Choose which bitcount algorithm to use. */
void setStrategy( enum strategy );

#endif

.

#include <limits.h>

#include "bitcount.h"

/* The number of entries needed in the table is equal to the number of unique
 * values a char can represent which is always UCHAR_MAX + 1*/
static unsigned char _bitCountTable[UCHAR_MAX + 1];
static unsigned int _lookupTableInitialized = 0;

static int _defaultBitCount( unsigned int val ) {
    int count;

    /* Starting with:
     * 1100 - 1 == 1011,  1100 & 1011 == 1000
     * 1000 - 1 == 0111,  1000 & 0111 == 0000
     */
    for ( count = 0; val; ++count )
        val &= val - 1;

    return count;
}

/* Looks up each byte of the integer in a lookup table.
 *
 * The first time the function is called it initializes the lookup table.
 */
static int _tableBitCount( unsigned int val ) {
    int bCount = 0;

    if ( !_lookupTableInitialized ) {
        unsigned int i;
        for ( i = 0; i != UCHAR_MAX + 1; ++i )
            _bitCountTable[i] =
                ( unsigned char )_defaultBitCount( i );

        _lookupTableInitialized = 1;
    }

    for ( ; val; val >>= CHAR_BIT )
        bCount += _bitCountTable[val & UCHAR_MAX];

    return bCount;
}

static int ( *_bitcount ) ( unsigned int ) = _defaultBitCount;

const char *strategyNames[] = { "onTheFly", "lookupTable" };

void setStrategy( enum strategy s ) {
    switch ( s ) {
    case onTheFly:
        _bitcount = _defaultBitCount;
        break;
    case lookupTable:
        _bitcount = _tableBitCount;
        break;
    case strategyCount:
        break;
    }
}

/* Just a forwarding function which will call whichever version of the
 * algorithm has been selected by the client 
 */
int bitcount( unsigned int val ) {
    return _bitcount( val );
}

#ifdef _BITCOUNT_EXE_

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/* Use the same sequence of pseudo random numbers to benmark each Hamming
 * Weight algorithm.
 */
void benchmark( int reps ) {
    clock_t start, stop;
    int i, j;
    static const int iterations = 1000000;

    for ( j = 0; j != strategyCount; ++j ) {
        setStrategy( j );

        srand( 257 );

        start = clock(  );

        for ( i = 0; i != reps * iterations; ++i )
            bitcount( rand(  ) );

        stop = clock(  );

        printf
            ( "\n\t%d psudoe-random integers using %s: %f seconds\n\n",
              reps * iterations, strategyNames[j],
              ( double )( stop - start ) / CLOCKS_PER_SEC );
    }
}

int main( void ) {
    int option;

    while ( 1 ) {
        printf( "Menu Options\n"
            "\t1.\tPrint the Hamming Weight of an Integer\n"
            "\t2.\tBenchmark Hamming Weight implementations\n"
            "\t3.\tExit ( or cntl-d )\n\n\t" );

        if ( scanf( "%d", &option ) == EOF )
            break;

        switch ( option ) {
        case 1:
            printf( "Please enter the integer: " );
            if ( scanf( "%d", &option ) != EOF )
                printf
                    ( "The Hamming Weight of %d ( 0x%X ) is %d\n\n",
                      option, option, bitcount( option ) );
            break;
        case 2:
            printf
                ( "Please select number of reps ( in millions ): " );
            if ( scanf( "%d", &option ) != EOF )
                benchmark( option );
            break;
        case 3:
            goto EXIT;
            break;
        default:
            printf( "Invalid option\n" );
        }

    }

 EXIT:
    printf( "\n" );

    return 0;
}

#endif

สิ่งที่คุณสามารถทำได้คือ

while(n){
    n=n&(n-1);
    count++;
}

ตรรกะที่อยู่เบื้องหลังสิ่งนี้คือบิตของ n-1 ที่กลับด้านจากเซตบิตขวาสุดของ n ถ้า n = 6 คือ 110 แล้ว 5 คือ 101 บิตจะกลับด้านจากบิตที่ตั้งค่าขวาสุดของ n ดังนั้นถ้าเรา & ทั้งสองนี้เราจะทำให้บิตขวาสุด 0 ในการวนซ้ำทุกครั้งและไปที่บิตขวาสุดถัดไปเสมอนับนับบิตเซตความซับซ้อนของเวลาที่เลวร้ายที่สุดจะเป็น O (logn) เมื่อตั้งค่าทุกบิต