Question

I have a counter that’s used by multiple threads to write to a specific element in an array. Here’s what I have so far…

int count = 0;
pthread_mutex_t count_mutex;

void *Foo()
{
    // something = random value from I/O redirection
    pthread_mutex_lock(&count_mutex);
    count = count + 1;
    currentCount = count;
    pthread_mutex_unlock(&count_mutex);
    // do quick assignment operation. array[currentCount] = something
}
main()
{
    // create n pthreads with the task Foo
}

The problem is that it is ungodly slow. I’m accepting a file of integers as I/O redirection and writing them into an array. It seems like each thread spends a lot of time waiting for the lock to be removed. Is there a faster way to increment the counter?

Note: I need to keep the numbers in order which is why I have to use a counter vs giving each thread a specific chunk of the array to write to.

Answer 1

You need to use interlocking. Check out the Interlocked* function on windows, or apple’s OSAtomic* functions, or maybe libatomic on linux.

If you have a compiler that supports C++11 well you may even be able to use std::atomic.