Fastest way to iterate over bits

Question

I have been working on a chess engine for a while and its fairly strong (about 2700 CCRL) and was wondering the following thing:

---

most top-level chess engines use bitboards. they are basically just 64-bit numbers which represent some binary data like if a square is occupied or not. There are many applications where bitboards are coming in handy but in many scenarios, I need to iterate over all the bits and use the index at which the bit has been set.

Some functions I defined beforehand:

typedef uint64_t U64;
typedef int8_t Square;  //its signed for different reasons

/**
 * returns the index of the LSB
 * @param bb
 * @return
 */
inline Square bitscanForward(U64 bb) {
//    assert(bb != 0);
    return __builtin_ctzll(bb);
}


/**
 * resets the lsb in the given number and returns the result.
 * @param number
 * @return
 */
inline U64 lsbReset(U64 number) {
    return number & (number - 1);;
}

Using those two, I usually iterated bitboards like this:

U64 bb = ....

while(bb){
   Square s = bitscanForward(bb);
   ...
   bb = lsbReset(bb);
}

An alternative solution was:

for(;bb!=0;bb=lsbReset(bb)){
   Square s = bitscanForward(bb);
   ...
}

yet the second one turns out to be slower (for some reason).

My questions therefor are:

1. Why is the second approach slower?
2. Are there even faster approaches? Especially in terms of reducing clock cycles by adjusting some computations.

EDIT 1

As wished, I post my testing code. In fact I found a small mistake and both of them run at the same speed. Yet the question remains if there are better implementations.

  U64 k = randU64();
    printBitmap(k);
    
    startMeasure();
    int sum = 0;
    for(int i = 0; i < 1e8; i++){
        U64 copy = k;
        while(copy){
            Square s = bitscanForward(copy);
            sum += s;
            
            copy = lsbReset(copy);
        }
    }
    std::cout << stopMeasure() << "ms sum="<<sum << std::endl;
    
    startMeasure();
     sum = 0;
    for(int i = 0; i < 1e8; i++){
        U64 copy = k;
        for(;copy!=0;copy=lsbReset(copy)){
            Square s = bitscanForward(copy);
            sum += s;
    
        }
    }
    std::cout << stopMeasure() << "ms sum="<<sum << std::endl;

Which outputs:

10101001
01011111
00011111
00000111
01010001
00000011
00110001
10010100

1748ms sum=-1174182400
1757ms sum=-1174182400