CODEWITHSUNDEEP
c++multithreading
Jack
Jack

Reputation: 21

Reading information from a worker thread efficiently

I'm writing some computer vision software, here's a brief description to help clarify the problem:

My main program creates these thread, using boost, following this tutorial: http://blog.emptycrate.com/node/282

I am currently polling the threads in a tight loop to retrieve the data, e.g.:

while(1) {
    for(i=0; i<numCams; i++) {
        result[i] = cam[i]->getResult();
    }

    //do some stuff
}

This seems silly. Is there a standard way of letting the main program know that there is a new result and that it needs to be retrieved?

Thanks!

Upvotes: 2

Views: 144

Answers (5)

Nim
Nim

Reputation: 33655

I know this sounds a little odd, however consider using a boost::asio::io_service it's as close to a threadpool as you get currently. When you've captured an image, you can post to this service and the service can then execute a handler asynchronously to handle your image data.

Upvotes: 0

T.E.D.
T.E.D.

Reputation: 44804

In your case you are talking to hardware, so you may need to use whatever facilities your camera API provides for asynchronous notification of incomming data. Usually that will be some kind of callback you provide, or occasionally something like a Windows Event handle or Unix signal.

In general if you meant "standard" as in "part of the C++ standard", no. You need to use your OS's facilites for interprocess (or thread) condition signalling.

Note that if we were talking Ada (or Modula-2, or many other modern systems programming languages) the answer would have been "yes". I understand there is some talk of putting concurrency support of some kind into a future C++ standard.

In the meantime, there is the boost::thread library for doing this kind of thing. That isn't exactly "standard", but for C++ it is pretty close. I think for what you are trying to do, condition variables might be what you want. However, if you read over the whole facility, other simpler designs may occur to you.

Upvotes: 0

Gene Bushuyev
Gene Bushuyev

Reputation: 5538

What you need is a thread pool. The number of cameras isn't necessary the same as the optimal number of threads. Thread pool is optimized for performance. Then, you don't need to wait for condition or poll the jobs, you enqueue the jobs (most often it's std::function<void()>) in the thread pool, and that job object should perform all the required work. Use binders (std::bind) or lambda functions to create a job object.

Upvotes: 0

Puppy
Puppy

Reputation: 146940

Yes, you need to use synchronization. There are many forms depending on what you're using as a threading API, however the simplest is probably a condition variable.

Upvotes: 0

Yakov Galka
Yakov Galka

Reputation: 72489

Yes, you need to use condition variables (AKA events).

Upvotes: 2

Related Questions