CODEWITHSUNDEEP
c++multithreading
PBS
PBS

Reputation: 37

Multi Threading in c++

I have a class called MatrixAlt and i'm trying to multi thread a function to do some work on that matrix.

My general method worked when I just implemented it in a couple of functions. But when I try to bring it into the class methods, I get an error.

The problematic line (or where it highlights anyway) is 4 lines from the end and the error message is in the comments just above it. 

#include <vector>
#include <future>
#include <thread>

class MatrixAlt
{
    public:
    MatrixAlt();

    // initilaise the matrix to constant value for each entry
    void function01(size_t maxThreads);
    void function02(size_t threadIndex);

};

MatrixAlt::MatrixAlt()
{

}

void MatrixAlt::function02(size_t threadIndex)
{
    // do some stuff 
    return;

}


void MatrixAlt::function01(size_t maxThreads)
{

    // To control async threads and their results
    std::vector<std::future<bool>> threadsIssued;

    // now loop through all the threads and orchestrate the work to be done
    for (size_t threadIndex = 0; threadIndex < maxThreads; ++threadIndex)
    {
        // line 42 gives error:
        // 'MatrixAlt::function02': non-standard syntax; use '&' to create a pointer to member
        // 'std::async': no matching overloaded function found
        threadsIssued.push_back(std::async(function02, threadIndex));
    }
    return;
}

Upvotes: 2

Views: 239

Answers (2)

Surt
Surt

Reputation: 16119

Your first problem is solved like this

threadsIssued.push_back(std::async(&MatrixAlt::function02, this, threadIndex));

You need to specify the exact class::function and take its address and which instance of the class your doing it for, and then the parameters.

The second problem which you haven't see yet is this line

 std::vector<std::future<bool>> threadsIssued;

All those futures will be lost in scope exit, like tears in rain. Time to destroy.

Freely after Blade runner.

All those moments will be lost in time, like tears in rain. Time to die.

Upvotes: 1

Nir Friedman
Nir Friedman

Reputation: 17714

Whenever you have a member function in C++, that function takes the object itself as an implicit first argument. So you need to pass the object as well, but even then, it can't be called with the same syntax as a normal function that takes the object.

The simplest way to setup an asynchronous job in C++ is typically just to use lambdas. They've very clear and explicit. So, for example, you could change your call to:

threadsIssued.push_back(std::async([this] (size_t t) { this->function02(t);}, threadIndex));

This lambda is explicitly capturing the this pointer, which tells us that all of the function02 calls will be called on the same object that the calling function01 is called on.

In addition to being correct, and explicit, this also helps highlight an important point: all of the function02 objects will be running with mutable access to the same MatrixAlt object. This is very dangerous, so you need to make sure that function02 is thread safe, one way or another (usually easy if its conceptually const, otherwise perhaps need a mutex, or something else).

Upvotes: 0

Related Questions