更快的二进制加法C ++

Question

I want to improve the speed of my current binary addition problem. What it does is create 2 vectors with size K and to the first adds 1. Maybe it can't be faster but if it's possible please let me know.

Edit: Modified for changing const vector& a, const vector& b

#include <stdio.h>
#include <windows.h>
#include <iostream>
#include <vector>

using namespace std;

vector<int> BinaryAddition(const vector<int>& a, const vector<int>& b, int tam){
    vector<int> c(tam);
    int ac = 0;

    for(int i=tam-1; i>-1; i--){
        c[i] = ((a[i] ^ b[i]) ^ ac); //a xor b xor c
        ac = ((a[i] & b[i]) | (a[i] &ac)) | (b[i] & ac); 
    }

    return c;
}

/* retorna "a - b" en segundos */
double performancecounter_diff(LARGE_INTEGER *a, LARGE_INTEGER *b)
{
    LARGE_INTEGER freq;
    QueryPerformanceFrequency(&freq);
    return (double)(a->QuadPart - b->QuadPart) / (double)freq.QuadPart;
}

int main(int argc, char *argv[])
{
    LARGE_INTEGER t_ini, t_fin;
    double secs;

    QueryPerformanceCounter(&t_ini);

    int k=15;

    vector<int> uno1 (k,0);
    vector<int> pro (k,0);
    vector<int> pro1(k,0);

    uno1[k-1] = 1;

    pro1 = BinaryAddition(pro, uno1, k);

    QueryPerformanceCounter(&t_fin);

    secs = performancecounter_diff(&t_fin, &t_ini);
    printf("%.16g milliseconds\n", secs * 1000.0);

    return 0; 
}

Answer 1

First of all, this:

vector<int> BinaryAddition(vector<int> a, vector<int> b, int tam)

should be:

vector<int> BinaryAddition(const vector<int>& a, const vector<int>& b, int tam)

You are copying the input parameters vectors for no reason, pass them by reference rather than by value, which requires copying.

Another thing you could try which may improve the speed is a simple technique called loop unwinding (or unrolling) This will certainly not make your code more readable or prettier, but may actually speed it up a bit - but do compare it to the simple version compiled with maximum optimization (usually compiler's option -O3 ), cause it may happen that your compiler already does the same optimization (or a different one, with a better effect).

Answer 2

I just did a quick hack to make the obvious solution:

vector<int> BinaryAddition3(const vector<int> &a, const vector<int> &b, int tam){
    vector<int> c(tam);
    int ac = 0;

    for(int i=tam-1; i>-1; i--){
       int t = a[i]+b[i] + ac;
       ac = t > 1;
       c[i] = t & 1;
    }

    return c;
}

This is actually a fraction slower than the less clear xor/or variant posted in the original question - about 0.05ms slower. However, that is measuring only the actual add, not the whole vector, and for a binary number that is 35000 integers long - and it still only takes 0.1 ms per addition on my rather ancient AMD quad core processor.

In my testing, the creation/initialization of the array takes about half the total time as the measurement of the total time. Adding const reference makes it about twice as fast for the actual addition function. This is definitely faster than the ORIGINAL function, but like I said, it's marginally slower - but clearer.