CODEWITHSUNDEEP
c++multithreading
user81993
user81993

Reputation: 6603

Multiple threads writing into a single buffer concurrently

I have an output cointainer similar to this:

struct cont {
    std::mutex m;
    size_t offset;
    char* data;

    cont(size_t sizeB) {
        data = new char[sizeB];
    }

    void write(char* data, size_t sizeB) {
        m.lock();
        size_t off = offset;
        offset += sizeB;
        m.unlock();
        std::memcpy(this->data + off, data, sizeB);
    }
};

The idea is that I have many threads, each working on a dynamically sized workload and outputting data in no specific order into that container. The threads are triggered by server access and there is no telling how many are in concurrently or how much they will contribute.

The reason I'm questioning this is because as you can see, the main workload is outside the mutex lock since in theory, only the distribution of the available buffer needs to be synchronized and the threads shouldn't collide after that bit.

Its been working fine so far but from previous experience, threading problems can manifest themselves way down the road so is this considered a thread safe practice?

Upvotes: 2

Views: 2573

Answers (3)

Erik Alapää
Erik Alapää

Reputation: 2703

Seems OK. If you want to optimize, you could make the offset atomic, to avoid the mutex altogether. So, just declare

std::atomic<size_t> offset;

and the mutex can be removed.

Upvotes: 2

Always Confused
Always Confused

Reputation: 470

As it stands, I'm afraid this is incomplete: your solution correctly allocates space between multiple threads, but you also need a solution for threads to "commit" their writes. Imagine that one writer thread is indefinitely delayed in the midst of a memcpy (or even prior to commencing its memcpy). How does any other thread ever find out about this so that you can eventually use this buffer at all?

Upvotes: 1

ZaldronGG
ZaldronGG

Reputation: 1004

This seems perfectly safe. You're probably worried about trampling on "leftover" bytes concurrently when offset changes by a number which is not a multiple of 4 or 8 bytes. I wanted to alleviate your concerns by quoting the Standard, but the entry for memcpy points to the C Library Reference, which is scant on details. Nevertheless, the function treat the buffers as arrays of unsigned char, so it cannot reliably assume it can also optimize copying the tail when it's unaligned or an incomplete word, as that could constitute an out-of-bound access.

Upvotes: 0

Related Questions