std::async doesn't seem to spawn thread with std::launch::async

Question

I am writing a DCPU-16 emulator and I am calculating the real time clock speed of the CPU by launching a thread that calls the function getRealTimeCPUClock() in a separate thread. The problem is it seems that the future object's "valid" attribute is true even when it has not returned a value. As a result, when calling futureObj.get(), it then waits for getRealTimeCPUClock() to return.

With a launch policy of async (as opposed to deferred) isn't it supposed to launch the function into the background and then when it returns set the valid attribute to true?

Is this the wrong usage?

int getRealTimeCPUClock() {
    int cyclesBeforeTimer = totalCycles;
    sleep(1);

    return totalCycles - cyclesBeforeTimer;
}

void startExecutionOfProgram(char *programFileName)
{
    size_t lengthOfProgramInWords = loadProgramIntoRAM(programFileName);
    auto futureRealTimeClockSpeed = std::async(std::launch::async, getRealTimeCPUClock);

    while(programCounter < lengthOfProgramInWords) {

        if(futureRealTimeClockSpeed.valid()) {
            realTimeClockSpeed = futureRealTimeClockSpeed.get();
            futureRealTimeClockSpeed = std::async(std::launch::async, getRealTimeCPUClock);
        }
        step(); 
    }
}

score 3 · Accepted Answer · edited Oct 10 '12 at 09:13

3

valid() does not what you think it does (although the entry in cppreference suggests otherwise).

Here is what the Standard says about valid():

(§ 30.6.6/18) bool valid() const noexcept;

Returns: true only if *this refers to a shared state.

The value returned by valid() will be true as long as long as the future object is associated with a valid shared state, which is generally the case after you launched it using std::async and before you retrieve the result (using get()). The future will also be invalidated when you use the share() method to create a shared_future. None of this is related to what you are trying to do, i.e. checking whether the result is available.

To determine whether the result of a future is ready, I suggest using the wait_for() function with a delay of 0:

if (futureRealTimeClockSpeed.wait_for(std::chrono::seconds(0))
          == std::future_status::ready)
   /*...*/

edited Oct 10 '12 at 09:13

Christian Rau

45,360
10
108
185

answered Oct 10 '12 at 08:16

jogojapan

68,383
11
101
131

While your explanations are all correct, they are a bit inaccurate/misleading. The shared state referred to by the description of `valid` means, that this `std::future` shares state with a `std::promise`. It isn't directly related to the `share` method, whose behaviour of moving the future's state into a `std::shared_future` just has the removal of the future's shared state and thus the invalidation as a consequence. But in fact calling `get` will also invalidate the future. So `valid` actually checks if the future is connected to a promise and its value hasn't been retrieved yet. – Christian Rau Oct 10 '12 at 08:53
@ChristianRau Yes, that is true. I must admit my main point was to suggest a correct way of checking whether the result is available. I have now edited the answer to make it a little less misleading; but there is probably still room for further improvement (or a separate answer by someone else). – jogojapan Oct 10 '12 at 09:10

std::async doesn't seem to spawn thread with std::launch::async

1 Answers1