move() data back from thread - c++

Question

I have a class ('Buffer') that contains a < vector > of data and an analyze() function that does some computation on the data ('raw' and 'optimised').
class Buffer
{
public:
Buffer(){};
vector<Element> raw;
vector<Element> optimised; // DATA CALCULATED BASED ON RAW
[...]
void analyze() // COMPUTE THE OPTIMISED BUFFER
{
for(std::vector<Element>::iterator it = raw.begin(); it != raw.end(); ++it)
{
optimised.push_back(Element(it->a,it->p));
// DO SOME COMPUTATIONALLY INTENSIVE CALCULATIONS
for(i=1; i<9999999; i++)
t = 9./i;
}
};
};
Because I need to create a series of the above 'Buffer' objects and keep interactive framerates, I am running the analyze() function for each buffer object onto a separate thread.
The only working solution I found for this is to use unique_ptr for keeping my collection of buffer objects
std::unique_ptr<dynamica::Buffer> buffer; //TEMPORARY COLLECTOR
std::vector<std::unique_ptr<dynamica::Buffer>> queue; //COLLECTION OF ALL PREVIOUS BUFFERS
and hence use move() when passing each of these objects to the respective thread.
queue.push_back(move(buffer));
//RUN 'ANALYZE' IN PARALLEL IN BACKGROUND
std::thread t(&Buffer::analyze, move(queue.back()));
t.detach();
My problem (I suspect) is that after I move() my object to a new thread for doing the analyze() computation I can no loner access the variable and methods in it (once the parallel thread has finished) from the main thread.
//from the main thread, once I know the parallel thread doing analyze() has finished
queue[0]->someFunction() // CRASH! ERROR! BOOM!
PS: Here (C++ multiple threads and vectors) is a reference to how I managed to get the threading working - and why it's the only solution.

Answer 1

This isn't really a threading issue. This is a misunderstanding of move semantics I think, you have handed the queue over to the detached thread and thus no longer own it.
Edit (Example code) :
#include <vector>
#include <iostream>
#include <memory>
#include <thread>
class Element
{
public:
int a;
float p;
Element(int _a, float _p=1.0): a(_a), p(_p){};
};
class Buffer
{
public:
Buffer(){};
std::vector<Element> raw;
std::vector<Element> optimised; // DATA CALCULATED BASED ON RAW
void addElement(int _a,float _p=1.0) // FILL THE RAW BUFFER
{
raw.push_back(Element(_a,_p));
}
void compute() // COMPUTE THE OPTIMISED BUFFER
{
float t;
int i;
for(std::vector<Element>::iterator it = raw.begin(); it != raw.end(); ++it)
{
optimised.push_back(Element(it->a,it->p));
// DO SOME COMPUTATIONALLY INTENSIVE CALCULATIONS
std::cout << "Performing calculations..." << std::endl;
for(i=1; i<9999999; i++)
t = 9./i;
}
};
void clear() // ERASE BOTH BUFFERS
{
raw.clear();
optimised.clear();
}
const std::pair<std::vector<Element>::const_iterator, std::vector<Element>::const_iterator> someFunction()
{
return std::make_pair<std::vector<Element>::const_iterator, std::vector<Element>::const_iterator>(begin(optimised), end(optimised));
}
~Buffer() { clear(); }
};
int _tmain(int argc, _TCHAR* argv[])
{
Buffer origin;
auto buffer = std::make_shared<Buffer *>(&origin);
std::vector<decltype(buffer)> queue;
for(int i = 0; i < 10; i++ )
(*buffer)->addElement(i);
queue.push_back(buffer);
std::thread t(&Buffer::compute, *queue.back());
t.join(); // wait for results
auto result = (*queue.back())->someFunction();
for( auto ele = result.first; ele != result.second; ele++ )
{
std::cout << (*ele).a << std::endl;
}
return 0;
}