2

So I was browsing the Quake engine source code earlier today and stumbled upon some written utility functions. One of them was 'Q_memcpy':

void Q_memcpy (void *dest, void *src, int count)
{
    int             i;

    if (( ( (long)dest | (long)src | count) & 3) == 0 )
    {
        count>>=2;
        for (i=0 ; i<count ; i++)
            ((int *)dest)[i] = ((int *)src)[i];
    }
    else
        for (i=0 ; i<count ; i++)
            ((byte *)dest)[i] = ((byte *)src)[i];
}

I understand the whole premise of the function but I don't quite understand the reason for the bitwise OR between the source and destination address. So the sum of my questions are as follows:

  • Why does 'count' get used in the same bitwise arithmetic?
  • Why is that result's last two bits checked if they are differing?
  • What purpose does this whole check serve?

I'm sure it's something obvious but please excuse my ignorance because I haven't really delved into the more low level side of things when it comes to programming. I just find it interesting and want to learn more.

Simeon Laplev
  • 69
  • 1
  • 8
  • 1
    it is important to understand that `count & 3` is a test to see if the variable `count` is divisible by 4. Similarly, `count & 7` would test to see if it is divisible by 8, and so on. – bruceg May 23 '18 at 18:49
  • 1
    Yes, I understand now. Thank you for the feedback either way! I will keep this in mind from now on. – Simeon Laplev May 23 '18 at 18:52
  • 1
    @bruceg And even more important to understand that it will only work to test divisibility with powers of 2... – Eugene Sh. May 23 '18 at 18:52
  • Yes, I understood that @EugeneSh. The bitwise OR operations were confusing me a bit as well, but I got it! Thanks a bunch! – Simeon Laplev May 23 '18 at 18:54
  • @EugeneSh. yes... `count & 12` doesn't do a very good job of checking divisibility by 13. – bruceg May 23 '18 at 19:12

3 Answers3

3

It is finding out whether the source and destination pointers are int aligned, and whether the count is an exact int size of bytes.

If those three things are all true, the l.s. 2 bits of them all will be 0 (assuming pointers and int are 4 bytes). So the algorithm ORs the three values, and isolates the l.s. 2 bits.

In this case, it copies int by int. Otherwise it copies char by char.

If the test fails, a more sophisticated algorithm would copy some of the leading and trailing bytes char by char and the intermediate bytes int by int.

Weather Vane
  • 33,872
  • 7
  • 36
  • 56
2

The bitwise ORing and ANding with 3 is to check whether the source, destination and count are divisible by 4. If they are, the operation can work with 4-byte words, while this code is assuming int as 4 bytes. Otherwise the operation is performed bytewise.

Eugene Sh.
  • 17,802
  • 8
  • 40
  • 61
1

It first tests if all 3 arguments are divisible by 4. If - and only if - they all are, it proceeds with copying 4 bytes at a time.

I.e. this undecoded would be

if ((long) src % 4 == 0 && (long) dst % 4 == 0 && count % 4 == 0 )
{
    count = count / 4;
    for (i = 0; i < count; i++)
        ((int *)dest)[i] = ((int *)src)[i];
}

I am not sure if they tested their compiler and it generated bad code for even a test, and therefore they decided to write it in such a convoluted way. In any case, the x | y | z will guarantee that a bit n is set in the result if it is set in any of x, y or z. Therefore if the (x | y | z) & 3 results in 0, none of the numbers had either of the 2 lowest bits set, and therefore are divisible by 4.

Of course it would be rather silly to use now - the standard library memcpy in recent library implementations is almost certainly better than this.

Therefore, on recent compilers you can optimize all calls to Q_memcpy by switching them to memcpy. GCC could generate things like 64-bit or SIMD moves with memcpy depending on the size of area to be copied.

Antti Haapala -- Слава Україні
  • 129,958
  • 22
  • 279
  • 321