Thread: Different ways to add

I made a function to add two numbers together using bit manipulation. I started off writing the function add_a, then made a modified version add_b.

add_a seems to be 10-15% faster than add_b. The thing is is that in add_b I removed a variable, and a reset and a copy from in the loop. So why does it appear slower?

Code:

#include <stdio.h>
#include <limits.h>
#include <stdlib.h>
#include <time.h>
#define Uint8 unsigned char

Uint8 add_a(Uint8 a, Uint8 b)
{
    static Uint8 i, num = 0;
    static Uint8 result = 0;
    static Uint8 carry = 0;
    static Uint8 bit = 1;

    for(i=0; i<CHAR_BIT; i++)
    {        
        num = 0;
        if(a & bit) num++;
        if(b & bit) num++;
        if(carry)   num++;    
        if(num & 1) result |= bit;
        carry = (num & 2);
        bit <<= 1;
    }  

    return result;  
}

Uint8 add_b(Uint8 a, Uint8 b)
{
    static Uint8 i, num = 0;
    static Uint8 result = 0;
    static Uint8 bit = 1;

    for(i=0; i<CHAR_BIT; i++)
    {
        if(a & bit)num++;
        if(b & bit)num++;
        if(num & 1) result |= bit;
        num = (num & 2) ? 1: 0;
        bit <<= 1;
    }  
    return result;  
}

Uint8 add_c(Uint8 a, Uint8 b)
{
    static Uint8 i, num = 0;
    static Uint8 result = 0;
    static Uint8 bit = 1;

    for(i=0; i<CHAR_BIT; i++)
    {
        if(a & bit)
            if(b & bit)
                num += 2;
            else
                num += 1;
        else
            if(b & bit)
                num += 1;
                
        if(num & 1) result |= bit;
        num = (num & 2) ? 1: 0;
        bit <<= 1;
    }  
    return result;  
}

void test(int x, int y)
{
    unsigned start = clock(), i;
    for(i=0; i<50000000; i++) add_a(x, y);
    printf("A: <Time %u> <Result %u>\n", clock()-start, add_a(x, y));
    start = clock();
    for(i=0; i<50000000; i++) add_b(x, y);
    printf("B: <Time %u> <Result %u>\n", clock()-start, add_b(x, y));
    start = clock();
    for(i=0; i<50000000; i++) add_c(x, y);
    printf("C: <Time %u> <Result %u>\n", clock()-start, add_c(x, y));
}

int main()
{
    Uint8 a = 102;
    Uint8 b = 57;
    test(a, b);
    getchar();
}

Just out of curiosity, what's wrong with plain old: a + b?

vart: Yeah I guess my testing method dosent say a whole lot. I had a look at VTune. I got an AMD tho.

matsp: Removing the static declaration dosent seem to make much difference. In fact I only added the 'static' bit at the end as it made the function much faster when repeatedly called. I don't know if thats a good thing tho. I don't want to store the value; it just saves time allocating space for the variables (or thats the impression I get). Also, shifting then &ing dident seem to make much difference either, but thanks for the suggestion I hadent thought of that.

cpjust: I was planning on using it (or something like it) for adding big numbers which would be made out of a string of bytes.

Yeah, I guess its hardware/compiler specific. I'm using GCC. Also I had a go at using declaring variables as 'register' instead of 'static'. (Something I found in the bowels of the GNU C language extensions). Bizzarely it makes it a whole lot slower than normal variables even when I am only requesting one register.

I think you are probably right in that theres little point worrying about small speed differences here. I think i may go with version a as returning the carry would be handy, although if its static its not like it really matters too much anyway.

Cheers.

Yeah, it seems better to forget about the register thing. Tbh I'm not sure exactly which version gcc i'm using. I think its an old one, like 3.4.2 or something. IE: the version that came with Dev C++. Never bothered updating it.

Just tried downloading CodeAnalyst from AMD's site, but it gave me some XML parsing error thing. Still might see if I can get hold of it elsewhere. Might be fun to have a play around with.

Hmm. Maybe I should update it. I have gcc 4.2.2 on my linux computer, I'll test it on that later see if it makes a difference.

Cheers.