Question

is there a known, working code to add elements to a shared, initialized c-style array (of objects) in multiple threads simultaneously without having to use lock on that resource? i mean, to a continuous memory block where elements are not linked by pointers.

i mean, algorithm, not libraries etc.
i just want to fill an array with elements in, say, 20 threads without locks or having to specify array ranges for threads where to fill (much like lockfree linked lists).

im using slackware 13.37 64 bit, pthreads, intel c++ compiler, tcmalloc allocator.

update : thanks guys for your answers, you all have been helpful with your ideas; if i could, i would mark all your ideas as answers. however, im still struggling with my code. so ill put the code up later in another thread to see whats happening exactly with my code, so people could really focus.

Answer 1

Maybe I didn’t get the idea correctly, but the obvious solution is just to use std::atomic increment for current array index. Atomics on integral types are usually implemented as lock-free.

But if this is not true or your compiler doesn’t support C++11 you could just replace it with your compiler-specific lock-free function, e.g. InterlockedIncrement for VS or __sync_fetch_and_add for GCC.

For Intel C++ Compiler C++ 11 atomics are supported. Also you could use _InterlockedIncrement64 from ia64intrin.h header file, see page 147 of Intel(R) C++ Intrinsics Reference.

Sample code (proof that it works here)

#include <atomic>
#include <thread>
#include <iostream>

const uint max_count = 100;

std::atomic_uint count;
std::string data[max_count];

void thread_func(const char* str)
{
   while(true)
   {
      const uint index = count++;
      if(index >= max_count) break;
      // Use += to see defect if data was already initialized by other thread
      data[index] += str;
      std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
 }

 int main()
 {
    std::cout << "Atomic counter is lock-free: " << 
       (count.is_lock_free() ? "Yes!" : "No!") << std::endl;

    std::thread t1(thread_func, "Thread 1");
    std::thread t2(thread_func, "Thread 2");
    std::thread t3(thread_func, "Thread 3");

    t1.join();
    t2.join();
    t3.join();

    for(uint i = 0; i < max_count; ++i)
    {
       std::cout<< i << ": " << data[i] << std::endl;
    }

    return 0;
 }