Ist mit std::async oft für kleine Aufgaben performance-freundlich?

die C++ - Laufzeit-soll überwachen Sie die Anzahl der threads, die erstellt und Zeitplan std::async entsprechend

Nicht. Wenn der asynchrone Aufgaben sind in der Tat asynchron ausführen (und nicht als latente), dann ist alles, was erforderlich ist, dass Sie so ausgeführt, als ob in einem neuen thread. Es ist vollkommen gültig für einen neuen thread angelegt und gestartet, die für jede Aufgabe, ohne Rücksicht auf die hardware, die der beschränkten Kapazität für Parallelität.

Gibt es einen Hinweis:

[ Hinweis: Wenn diese Richtlinie festgelegt ist, die zusammen mit anderen Maßnahmen, wie zum Beispiel bei Verwendung eines policy-Wert von launch::async | launch::deferred,
Implementierungen sollten aufschieben Aufruf oder die Auswahl von der Politik
wenn keine weitere Parallelität effektiv ausgenutzt. —Ende Hinweis ]

Dies ist jedoch nicht-normativen und in jedem Fall zeigt es, daß einmal keine mehr Parallelität ausgenutzt werden kann, die Aufgaben kann verzögert werden, und somit ausgeführt, wenn jemand wartet auf das Ergebnis, anstatt immer noch asynchron und läuft sofort nach einem der vorherigen asynchronen tasks abgeschlossen ist, wie es wünschenswert wäre, für die maximale Parallelität.

Ist, dass, wenn wir 10 lange laufende Aufgaben und die Umsetzung kann nur ausführen, 4 parallel, dann die ersten 4 asynchrone und dann die letzten 6 verschoben werden kann. Warten auf den futures in der Folge führen Sie die zurückgestellten Aufgaben auf einen einzigen thread in Folge, wodurch die parallele Ausführung für diese Aufgaben.

Die note muss auch sagen, dass anstelle der Vertagung der Aufruf, die Auswahl des politischen verschoben werden kann. Das heißt, die Funktion kann immer noch laufen asynchron, aber diese Entscheidung kann hinausgezögert werden, sagen wir, bis eine der früheren Aufgaben abgeschlossen, zu befreien, einen Kern für eine neue Aufgabe. Aber nochmals, dies ist nicht erforderlich, der Hinweis ist nicht-normativ, und soweit ich weiß die Microsoft-Implementierung ist die einzige, die auf diese Weise verhält. Als ich sah auf einem anderen Umsetzung, libc++, es einfach ignoriert diesen Hinweis zusammen, so dass entweder std::launch::async oder std::launch::any Politik Ergebnis der asynchronen Ausführung in einem neuen thread.

(Ich glaube im Fall von Microsoft Ihre ConcRT-Bibliothek ist verantwortlich für diese?)

Microsoft-Implementierung scheint in der Tat so Verhalten, wie Sie beschreiben, aber dies ist nicht erforderlich und ein portables Programm kann sich nicht darauf berufen, dass das Verhalten.

Eine Möglichkeit Mobil limit, wie viele threads ausgeführt ist, etwas zu verwenden, wie ein semaphore:

#include <future>
#include <mutex>
#include <cstdio>

//a semaphore class
//
//All threads can wait on this object. When a waiting thread
//is woken up, it does its work and then notifies another waiting thread.
//In this way only n threads will be be doing work at any time.
//
class Semaphore {
private:
    std::mutex m;
    std::condition_variable cv;
    unsigned int count;

public:
    Semaphore(int n) : count(n) {}
    void notify() {
        std::unique_lock<std::mutex> l(m);
        ++count;
        cv.notify_one();
    }
    void wait() {
        std::unique_lock<std::mutex> l(m);
        cv.wait(l, [this]{ return count!=0; });
        --count;
    }
};

//an RAII class to handle waiting and notifying the next thread
//Work is done between when the object is created and destroyed
class Semaphore_waiter_notifier {
    Semaphore &s;
public:
    Semaphore_waiter_notifier(Semaphore &s) : s{s} { s.wait(); }
    ~Semaphore_waiter_notifier() { s.notify(); }
};

//some inefficient work for our threads to do
int fib(int n) {
    if (n<2) return n;
    return fib(n-1) + fib(n-2);
}

//for_each algorithm for iterating over a container but also
//making an integer index available.
//
//f is called like f(index, element)
template<typename Container, typename F>
F for_each(Container &c, F f) {
    Container::size_type i = 0;
    for (auto &e : c)
        f(i++, e);
    return f;
}

//global semaphore so that lambdas don't have to capture it
Semaphore thread_limiter(4);

int main() {
    std::vector<int> input(100);
    for_each(input, [](int i, int &e) { e = (i%10) + 35; });

    std::vector<std::future<int>> output;
    for_each(input, [&output](int i, int e) {
        output.push_back(std::async(std::launch::async, [] (int task, int n) -> int {
            Semaphore_waiter_notifier w(thread_limiter);
            std::printf("Starting task %d\n", task);
            int res = fib(n);
            std::printf("\t\t\t\t\t\tTask %d finished\n", task);
            return res;
        }, i, e));
    });

    for_each(output, [](int i, std::future<int> &e) {
        std::printf("\t\t\tWaiting on task %d\n", i);
        int res = e.get();
        std::printf("\t\t\t\t\t\t\t\t\tTask %d result: %d\n", i, res);
    });
}