Intrinsic Funktion _bittest langsamer?

int bitTestStandard(const long* array, long bitNumber, size_t len) {

    int numberOfSetBits = 0;

    for (size_t i = 0; i < len; i++) {

        numberOfSetBits += (*array & (1 << bitNumber)) ? 1 : 0;

        array++;

    }

    return numberOfSetBits;

}

int bitTestIntrinsic(const long* array, long bitNumber, size_t len) { 

    int numberOfSetBits = 0;

    for (size_t i = 0; i < len; i++) {

        numberOfSetBits += _bittest(array, bitNumber) ? 1 : 0;

        array++;

    }

    return numberOfSetBits;

}

const int testArraySize = 123456789;

const long testArrayBitNumber = 13;

long *testArray;

int _tmain(int argc, _TCHAR* argv[]) {

    testArray = new long[testArraySize];

    for (size_t i = 0; i < testArraySize; i++) {

        testArray[i] = i;

    }  

    auto tickCountIntrinsic = GetTickCount64();

    auto resultIntrinsic = bitTestIntrinsic(testArray, testArrayBitNumber, testArraySize);

    tickCountIntrinsic = GetTickCount64() - tickCountIntrinsic;

    auto tickCountStandard = GetTickCount64();

    auto resultStandard = bitTestStandard(testArray, testArrayBitNumber, testArraySize);

    tickCountStandard = GetTickCount64() - tickCountStandard;

    printf("Intrinsic: %lld, %d, Standard: %lld, %d\n",  tickCountIntrinsic, resultIntrinsic, tickCountStandard, resultStandard);

    return 0;

}

  testArray = new long[testArraySize];

00C8100D  push        1D6F3454h  

00C81012  call        dword ptr ds:[0C82094h]  

00C81018  movdqa      xmm1,xmmword ptr ds:[0C82130h]  

00C81020  add         esp,4  

00C81023  mov         dword ptr ds:[00C83368h],eax  

  for (size_t i = 0; i < testArraySize; i++) {

00C81028  xor         ecx,ecx  

00C8102A  mov         edx,eax  

00C8102C  lea         esp,[esp]  

00C81030  movd        xmm0,ecx  

00C81034  pshufd      xmm0,xmm0,0  

00C81039  paddd       xmm0,xmm1  

00C8103D  add         ecx,4  

    testArray[i] = i;

00C81040  movdqu      xmmword ptr [edx],xmm0  

00C81044  lea         edx,[edx+10h]  

00C81047  cmp         ecx,75BCD14h  

00C8104D  jb          wmain+30h (0C81030h)  

  for (size_t i = 0; i < testArraySize; i++) {

00C8104F  cmp         ecx,75BCD15h  

00C81055  jae         wmain+6Ch (0C8106Ch)  

00C81057  jmp         wmain+60h (0C81060h)  

00C81059  lea         esp,[esp]  

    testArray[i] = i;

00C81060  mov         dword ptr [eax+ecx*4],ecx  

00C81063  inc         ecx  

00C81064  cmp         ecx,75BCD15h  

00C8106A  jb          wmain+60h (0C81060h)  

  }  

  auto tickCountIntrinsic = GetTickCount64();

00C8106C  mov         ebx,dword ptr ds:[0C82000h]  

00C81072  call        ebx  

  auto resultIntrinsic = bitTestIntrinsic(testArray, testArrayBitNumber, testArraySize);

00C81074  mov         ecx,dword ptr ds:[0C83368h]  

  auto resultIntrinsic = bitTestIntrinsic(testArray, testArrayBitNumber, testArraySize);

00C8107A  mov         ebp,eax  

00C8107C  mov         dword ptr [esp+10h],edx  

00C81080  xor         edi,edi  

  }  

  auto tickCountIntrinsic = GetTickCount64();

00C81082  mov         esi,75BCD15h  

00C81087  jmp         wmain+90h (0C81090h)  

00C81089  lea         esp,[esp]  

  auto resultIntrinsic = bitTestIntrinsic(testArray, testArrayBitNumber, testArraySize);

00C81090  bt          dword ptr [ecx],0Dh  

00C81094  mov         eax,0  

00C81099  setb        al  

00C8109C  lea         ecx,[ecx+4]  

00C8109F  add         edi,eax  

00C810A1  dec         esi  

00C810A2  jne         wmain+90h (0C81090h)  

  tickCountIntrinsic = GetTickCount64() - tickCountIntrinsic;

00C810A4  call        ebx  

00C810A6  sub         eax,ebp  

00C810A8  mov         ecx,edx  

00C810AA  sbb         ecx,dword ptr [esp+10h]  

00C810AE  mov         dword ptr [esp+1Ch],eax  

00C810B2  mov         dword ptr [esp+18h],ecx  

  auto tickCountStandard = GetTickCount64();

00C810B6  call        ebx  

00C810B8  mov         ecx,dword ptr ds:[0C83368h]  

00C810BE  mov         dword ptr [esp+14h],edx  

00C810C2  xor         edx,edx  

00C810C4  xor         ebx,ebx  

00C810C6  mov         dword ptr [esp+10h],eax  

00C810CA  add         ecx,8  

00C810CD  mov         ebp,273EF07h  

  auto resultStandard = bitTestStandard(testArray, testArrayBitNumber, testArraySize);

00C810D2  mov         eax,dword ptr [ecx-8]  

00C810D5  shr         eax,0Dh  

  auto resultStandard = bitTestStandard(testArray, testArrayBitNumber, testArraySize);

00C810D8  and         eax,1  

00C810DB  add         esi,eax  

00C810DD  mov         eax,dword ptr [ecx-4]  

00C810E0  shr         eax,0Dh  

00C810E3  and         eax,1  

00C810E6  add         ebx,eax  

00C810E8  mov         eax,dword ptr [ecx]  

00C810EA  shr         eax,0Dh  

00C810ED  and         eax,1  

00C810F0  add         edx,eax  

00C810F2  lea         ecx,[ecx+0Ch]  

00C810F5  dec         ebp  

00C810F6  jne         wmain+0D2h (0C810D2h)  

  tickCountStandard = GetTickCount64() - tickCountStandard;

00C810F8  lea         eax,[edx+ebx]  

00C810FB  add         esi,eax  

00C810FD  call        dword ptr ds:[0C82000h]  

00C81103  sub         eax,dword ptr [esp+10h]

;; %%% bts, btr, btc, bt.

;; In general these instructions are *slow* when applied to memory,

;; since they enforce atomic operation.  When applied to registers,

;; it depends on the cpu implementation.  They're never faster than

;; the corresponding and/ior/xor operations, so with 32-bit there's

;; no point.  But in 64-bit, we can't hold the relevant immediates

;; within the instruction itself, so operating on bits in the high

;; 32-bits of a register becomes easier.

;;

;; These are slow on Nocona, but fast on Athlon64.  We do require the use

;; of btrq and btcq for corner cases of post-reload expansion of absdf and

;; negdf respectively, so they can never be disabled entirely.