Tut async(launch::async) in C++11 machen, thread-pools veraltet für die Vermeidung von teuren thread erstellen?

Ist es Locker sich auf diese Frage beziehen: Sind std::thread gebündelt in C++11?. Obwohl die Frage unterscheidet sich, das Ziel ist das gleiche:

Frage 1: Macht es noch Sinn die zu verwenden Sie Ihre eigenen (oder 3rd-party-Bibliothek), thread-pools zu vermeiden, teure thread erstellen?

Den Abschluss, die andere Frage war, dass Sie sich nicht darauf verlassen kann std::thread gepoolt werden (es könnte oder könnte es nicht). Allerdings std::async(launch::async) zu haben scheint, eine viel höhere chance zu einem Pool zusammengefasst werden.

Er glaube nicht, dass es gezwungen ist, die Norm, aber IMHO würde ich erwarten, dass alle guten C++11-Implementierungen verwenden würden, thread-pooling, wenn thread-Erstellung ist langsam. Nur auf Plattformen, wo es günstig einen neuen thread erstellen, würde ich erwarten, dass Sie immer laichen einen neuen thread.

Frage 2: Das ist genau das, was ich denke, aber ich habe keine Fakten um das zu beweisen. Ich kann sehr gut falsch sein. Ist es eine Vermutung?

Schließlich, hier habe ich einige Beispiel-code, der erste zeigt, wie ich denke, dass thread-Erstellung können ausgedrückt werden, indem async(launch::async):

Beispiel 1:

 thread t([]{ f(); });
 //...
 t.join();

wird

 auto future = async(launch::async, []{ f(); });
 //...
 future.wait();

Beispiel 2: Feuer-und-vergessen-thread

 thread([]{ f(); }).detach();

wird

 //a bit clumsy...
 auto dummy = async(launch::async, []{ f(); });

 //... but I hope soon it can be simplified to
 async(launch::async, []{ f(); });

Frage 3: Würden Sie es vorziehen, die async Versionen der thread Versionen?

Der rest ist nicht mehr Teil der Frage, aber nur zur Klarstellung:

Warum muss der Rückgabewert zugewiesen werden, um eine dummy-variable?

Leider, in der aktuellen C++11 standard-Kräfte, die Sie erfassen den Rückgabewert von std::async werden, sonst ist der Destruktor ausgeführt wird, die blockiert wird, bis die Aktion beendet. Es wird von einigen als ein Fehler in der standard - (z.B., von Herb Sutter).

Diesem Beispiel aus cppreference.com zeigt es schön:

{
  std::async(std::launch::async, []{ f(); });
  std::async(std::launch::async, []{ g(); });  //does not run until f() completes
}

Weiteren Klärung:

Ich weiß, dass thread-pools können auch andere legitime verwendet, aber in dieser Frage bin ich nur daran interessiert, den Aspekt der Vermeidung von teuren thread-Erstellung Kosten.

Ich denke, es gibt immer noch Situationen, wo thread-pools sind sehr nützlich, vor allem, wenn Sie mehr Kontrolle über Ressourcen.
Zum Beispiel, ein server kann entscheiden, zu handhaben, dass nur eine bestimmte Anzahl von Anfragen gleichzeitig garantieren schnelle Reaktionszeiten und erhöhen die Vorhersagbarkeit der Speichernutzung. Thread-pools sollte in Ordnung sein, hier.

Thread-lokalen Variablen kann auch ein argument sein für die eigene thread-pools, aber ich bin mir nicht sicher, ob es relevant ist, in der Praxis:

  • Erstellen einen neuen thread mit std::thread startet, ohne initialisiert thread-lokalen Variablen. Vielleicht ist dies nicht das, was Sie wollen.
  • In threads hervorgebracht von async es ist etwas unklar für mich, weil der thread hätte wiederverwendet. Von meinem Verständnis, thread-lokale Variablen nicht garantiert werden zurückgesetzt, aber ich kann mich irren.
  • Mit Ihrem eigenen (mit fester Größe) thread-pools, auf der anderen Seite, gibt Ihnen die volle Kontrolle, wenn Sie es wirklich brauchen.
  • "Aber std::async(launch::async) zu haben scheint, eine viel höhere chance zu einem Pool zusammengefasst werden." Nein, ich glaube, seine std::async(launch::async | launch::deferred) werden können gebündelt. Mit nur launch::async die Aufgabe soll gestartet werden, in einem neuen thread, unabhängig davon, was andere tasks ausgeführt werden. Mit der Politik launch::async | launch::deferred dann die Umsetzung, erhält zu wählen, die Politik, aber vor allem wird es, zu verzögern, die Wahl, die Politik. Das heißt, es kann warten, bis ein thread in einem thread-pool zur Verfügung stehen und dann wählen Sie die async-Politik.
  • Soweit ich weiß, nur VC++ verwendet einen thread-pool mit std::async(). Ich bin immer noch neugierig zu sehen, wie Sie die Unterstützung von nicht-trivialen thread_local Destruktoren in einem thread-pool.
  • Das kann sehr einfach realisiert werden, in deren Umsetzung mit RegisterWaitForSingleObject mit dem "Objekt" als das thread-handle. Wenn der thread beendet werden, dessen handle wird signalisiert werden, und der Rückruf in der Warteschlange ausgeführt im thread-pool. Der Rückruf kann dann rufen Sie nicht-trivialen Destruktor für TLS. Ich weiß nicht, ob Sie das tun (noch).
  • Ich trat durch die libstdc++ kommt mit gcc 4.7.2 und festgestellt, dass, wenn die launch-Politik ist nicht genau launch::async dann wird es behandelt, als wäre es nur launch::deferred und nie führt es-asynchron - also in der Tat, diese version von libstdc++ "wählt" immer latente gezwungen, es sei denn sonst.
  • Mein Punkt über thread_local Destruktoren war, dass die Zerstörung auf den thread beenden ist nicht ganz richtig, bei der Verwendung von thread-pools. Wenn eine Aufgabe ausgeführt wird asynchron ausgeführt wird, 'als ob in einem neuen thread', gemäß der Spezifikation, was bedeutet, dass jede async-task bekommt seinen eigenen thread_local Objekte. Ein thread-pool-basierte implementation hat, Besondere Sorgfalt walten, um sicherzustellen, dass die Aufgaben, welche die gleiche backing-thread immer noch so Verhalten, als wenn Sie Ihre eigenen thread_local Objekte. Betrachten Sie dieses Programm: pastebin.com/9nWUT40h
  • Mit "als-ob in einem neuen thread" in der spec-war ein großer Fehler meiner Meinung nach. std::async hätte eine schöne Sache für die Leistung - es hätte der standard kurz ausgeführt-der task-Ausführung-system, natürlich gesichert durch einen thread-pool. Gerade jetzt, es ist nur ein std::thread mit etwas Mist geheftet, um die thread-Funktion in der Lage sein, um einen Wert zurückzugeben. Oh, und Sie hat redundante "latente" Funktionen, die überschneidungen der Arbeit der std::function komplett.
  • Upvote für "den aktuellen standard C++11 Kräfte, die Sie erfassen den Rückgabewert von std::async, da sonst der Destruktor ausgeführt wird, die blockiert wird, bis die Aktion beendet." Ist es möglich, dass 'Zukunft' Verwandte features wurden implementiert mit shared_ptr, so hat es eine bessere Speicherverwaltung und brauchen nicht zu streng / komisch auf Zerstörung Teil?

InformationsquelleAutor Philipp Claßen | 2013-01-16
  1. 42

    Frage 1:

    Wechselte ich diese aus dem original, weil das original war falsch. Ich hatte den Eindruck, dass Linux-thread-Erstellung war sehr Billig und nach Tests habe ich festgestellt, dass der overhead des Funktionsaufrufs in einem neuen thread im Vergleich zu einem normalen ist enorm. Der Aufwand für die Erstellung von einem thread zu behandeln, eine Funktion aufrufen, ist so etwas wie 10000 oder mehr mal länger als bei einem einfachen Aufruf der Funktion. Also, wenn Sie die Ausstellung viele kleine Funktion ruft ein thread pool kann eine gute Idee sein.

    Es ist ziemlich offensichtlich, dass der standard-C++ - Bibliothek, die Schiffe mit g++ nicht thread-pools. Aber ich kann definitiv sehen, ein Fall für Sie. Selbst mit dem overhead, dass schieben Sie den Aufruf durch irgendeine Art von inter-thread-Warteschlange, es würde wahrscheinlich billiger sein, als der Start eines neuen thread. Und der standard dies erlaubt.

    IMHO, das Linux-kernel-Leute sollten daran arbeiten, dass thread-Erstellung billiger als es derzeit ist. Aber die standard C++ - Bibliothek sollten auch erwägen, den pool zu implementieren launch::async | launch::deferred.

    Und die OP ist richtig, mit ::std::thread starten ein thread natürlich erzwingt die Erstellung eines neuen thread, anstatt eine aus einem pool. So ::std::async(::std::launch::async, ...) bevorzugt.

    Frage 2:

    Ja, im Grunde ist diese 'implizit', startet einen thread. Aber wirklich, es ist immer noch ziemlich offensichtlich, was vor sich geht. Also ich denke nicht wirklich, dass das Wort implizit ist ein besonders gutes Wort.

    Ich bin auch nicht davon überzeugt, dass Sie zu zwingen, zu warten, für die Rückkehr vor der Zerstörung ist unbedingt ein Fehler. Ich weiß nicht, dass Sie sollten mit den async Aufruf von create 'daemon' - threads, die nicht wieder erwartet. Und wenn Sie werden wieder erwartet, es ist nicht OK zu ignorieren Ausnahmen.

    Frage 3:

    Persönlich, ich mag thread startet zu explizit sein. Ich lege viel Wert auf Inseln, wo Sie garantieren können, die einen seriellen Zugriff. Andernfalls Sie am Ende mit veränderbarer Zustand, dass Sie immer auf der Verpackung eines mutex irgendwo Rum und erinnern, es zu benutzen.

    Ich mochte die Arbeit Warteschlange Modell eine ganze Menge besser als die "Zukunft" - Modell, weil es "Inseln der Serie" herumliegen, so können Sie effektiver behandeln änderbarer Zustand.

    Aber wirklich, es hängt davon ab, was genau Sie tun.

    Performance-Test

    So, getestet habe ich die performance der verschiedenen Methoden aufrufen, die Dinge und kam mit diesen zahlen auf einem 8-core (AMD Ryzen 7 2700X) system läuft Fedora 29 clang kompiliert mit version 7.0.1 und libc++ (nicht libstdc++):

       Do nothing calls per second:   35365257                                      
        Empty calls per second:   35210682                                      
   New thread calls per second:      62356                                      
 Async launch calls per second:      68869                                      
Worker thread calls per second:     970415

    Und einheitlichen, auf meinem MacBook Pro 15" (Intel(R) Core(TM) i7-7820HQ CPU @ 2.90 GHz) mit Apple LLVM version 10.0.0 (clang-1000.10.44.4) unter OSX 10.13.6, bekomme ich diese:

       Do nothing calls per second:   22078079
        Empty calls per second:   21847547
   New thread calls per second:      43326
 Async launch calls per second:      58684
Worker thread calls per second:    2053775

    Für den worker-thread, fing ich an, einen Faden, dann eine lockless-Warteschlange zu senden, die Anträge auf einen anderen thread warten und dann für ein "It' s done" zu Antworten zurück zu senden.

    Dem "nichts Tun" ist nur zu testen, der Aufwand der Testumgebung.

    Es ist klar, dass der Aufwand der Einführung eines thread ist enorm. Und auch den worker-thread mit der inter-thread-queue verlangsamt Dinge nach unten mit einem Faktor von 20 oder so auf Fedora-25 in einer VM, und von über 8 auf native OS X.

    Erstellte ich ein Bitbucket-Projekt hält der code, den ich verwendet für den performance-test. Es kann hier gefunden werden: https://bitbucket.org/omnifarious/launch_thread_performance

    • Ich schliesse mich auf die work-queue-Modell, aber das erfordert ein "pipeline" - Modell, das möglicherweise nicht für jeden verwenden, der den gleichzeitigen Zugriff.
    • Ich habe eine Bibliothek zu Sortieren, kombinieren Sie. Man kann etwas auf eine work-queue für einen anderen thread, dass die Ergebnisse in etwas, die auf der Warteliste für den original-thread-Arbeit-Warteschlange, wenn es fertig ist. Diese Art der sieht aus wie eine Zukunft.
    • Ich sehe das mehr als eine asynchrone Bestätigung. Sieht zwar nett, hoffe, Sie veröffentlichen es.
    • Ich möchte zum implementieren von auto-wrapping für Funktionen, so können Sie es verwenden, um zu schreiben, ganze Ausdrücke, die die evaluaion verzögert wird, bis alle Ergebnisse sind für Sie ausgewertet werden. Das ist, was blockiert mich von etwas, was ich als release-ready ist, und warum ich habe gefragt, alle die komischen kompliziert Vorlage Fragen.
    • Sieht für mich wie expression templates (für die Betreiber) kann verwendet werden, zu verfassen, die Ergebnisse für Funktionsaufrufe benötigen Sie einen call - Methode, aber ich Schätze wegen überlastung könnte es etwas schwieriger.
    • href="http://codereview.stackexchange.com/questions/20665/could-this-deferred-execution-scheme-be-any-simpler" title="konnte das verzögerte Ausführung Schema einfacher sein">codereview.stackexchange.com/questions/20665/...
    • "sehr Billig" ist relativ, um Ihre Erfahrung. Ich finde Linux thread-Erstellung von overhead zu sein, erhebliche für meine Nutzung.
    • Ich habe eine public-domain ein, die mithilfe von modernen c++11-und Sie fügt hinzu, etwa 50 Mikrosekunden overhead pool.enque tatsächliche Arbeit hinter gemacht, was für mich ist waaay zu viel. Gibt es etwas in der 5-10 Mikrosekunden-Bereich?
    • "Ich weiß, dass im Linux-thread-Erstellung wurde sehr Billig" - bekomme ich eine Ressource zu Lesen dazu?
    • Meine Informationen auf, die ziemlich alt war und kam etwa ab dem Jahr 2003, als Ulrich Drepper bekam ein bug sein aber und implementiert die futex system-call und generell verbesserte Linux-threading deutlich. Auch: cs.utexas.edu/~witchel/372/Vorträge/POSIX_Linux_Threading.pdf
    • Ich dachte, es war viel billiger als es ist. Ich aktualisiert meine Antwort vor einer Weile reflektieren einen test habe ich zu entdecken, die tatsächlichen Kosten.
    • Im ersten Teil sind Sie ein wenig zu unterschätzen, wie viel getan werden muss, um die Bedrohung, und wie wenig getan werden muss, um eine Funktion aufzurufen. Ein Funktionsaufruf und return ist ein paar CPU-Instruktionen zu manipulieren, dass ein paar bytes auf dem stack. Eine Bedrohung der Schöpfung bedeutet: 1. die Zuteilung von stack 2. Durchführung um einen Systemaufruf handelt, 3. erstellen von Datenstrukturen im kernel und verknüpfen Sie Sie, packende Schlösser entlang des Weges, 4. wartet der scheduler zum ausführen der thread, 5. Kontextwechsel zu dem thread. Jeder dieser Schritte an sich nimmt viel mehr als die komplexe Funktion aufruft.
    • Als solche finde ich ein bisschen dick, zu sagen: "der Linux-kernel die Menschen sollten daran arbeiten, dass thread-Erstellung billiger als es derzeit ist". Die Jungs arbeiten hart, um zu liefern eine Leistung, die andere Betriebssysteme nur träumen können, aber Sie haben zu bleiben innerhalb der Spezifikationen zu. Thread-Erstellung ist eine teure operation, per definition.
    • Warum macht eine Menge durchgeführt werden müssen, um einen thread erstellst? Es gibt Architekturen, in denen das erstellen und zerstören von threads durch die Hunderte oder Tausende sind die norm. Vielleicht ist es das Konzept von dem, was ein thread ist, der muss Wiederaufgreifen. Vielleicht sollte es eine CPU ändern, mit dem Sie einen Befehl zu rekrutieren, einen anderen Kern, so können Sie teilen Sie Ihre mittlere (1000-50000 iteration) Schleife in der Mitte. All diese Dinge sind möglich.
    • Ein Funktionsaufruf dauert etwa 20 CPU-Zyklen (Sie gemessen weniger, weil einige der overhead verborgen war hinter Ihr Testumgebung). Eine Speicherbelegung kann leicht mit 200 CPU-Zyklen. Ein Systemaufruf ist nicht weniger als etwa 200ns. Grabbing eine Sperre inter-Bedrohung, die Kommunikation, die durchgeführt werden muss innerhalb des Kernels, erwarten Sie etwas rund eine Mikrosekunde. Und ich habe noch nicht begonnen, auf den Aufwand der Einstellung Seite-Tische oder das Spülen der TLB. Wenn spezielle hardware ermöglicht die schnellere thread-Erstellung, ist es, weil die hardware optimiert ist, dass X86-CPUs nicht.
    • Grabbing eine Sperre, die auf Linux, erfordert keinen system-Aufruf an alle. Es gibt nur ein system nennen, wenn es Streit. Getestet hab ich dies mit einem hoch umkämpften int counter, eingewickelt in ein ::std::mutex. In zählen bis 10000 mit zwei threads gab es so etwas wie 10 Anrufe, um den futex system nennen. Die Intel-Leute hören die Linux-Leute. Wenn ein CPU-Wechsel würde helfen, es kann passieren. Warum müssen Sie alles tun, mit der TLB?
    • Ich Sprach über die sperren, die müssen ergriffen werden, innerhalb der kernel. Denken Sie daran, den kernel selbst ist eine parallele Anwendung. Es gibt einige Gemeinkosten in die hardware selbst, die machen sogar Atomare Operationen für die inter-thread Kommunikation deutlich langsamer als die normalen Speicher zugreift. Der TLB ins Spiel kommt, wenn eine Bedrohung gestartet wird, auf einem anderen Kern, wo der vorhergehenden Zeitschlitz verwendet wurde, durch etwas anderes als Ihren Prozess. Wir sprechen über parallelen hier, nachdem alle. Ich weiß nicht, ob linux optimieren können TLB-flush Weg, wenn der Wechsel zwischen threads desselben Prozesses, wenn.
    • Ich denke, es gibt eine Menge von 'out-of-the-box" - Möglichkeiten. Ich versuche nicht zu implizieren, dass die kernel-Leute sind inkompetent. Ich vermute, thread-Erstellung auf Linux ist billiger als NT zum Beispiel. Nein, ich denke nur, dass einige wirklich kreativen Denkens angewandt, um dieses problem könnte einige sehr interessante und beeindruckende Ergebnisse. Ich nehme an, sagen "Sie brauchen, um thread-Erstellung schneller" nicht so ganz über.
    • Nun ich denke, wir sind wirklich beginnen, zu Stimmen 🙂 wie auch immer, ich denke, dass die aktuellen X86-CPUs sind nicht wirklich gebaut, die entweder für eine schnelle thread-switching, noch für die schnelle thread-Erstellung. Sie sind gebaut für eine optimale benchmark-performance, was bedeutet, dass nichts so teuer wie ein thread-Erstellung nicht wirklich optimiert werden, denn es wird nicht zeigen, bis in den benchmarks in den ersten Platz. Es wäre interessant zu wissen, was erreicht werden könnte, wenn wir anfangen, mit CPU-Befehlssatz-design - habe ich das Gefühl, dass wir in der Lage sein, um produzieren viel bessere Ergebnisse in der multi-threading und Virtualisierung.
    • Eine Idee wäre, eine Anweisung zum starten eines thread, nutzte eine Art von "gratis-core" - Zustand gehalten, in den gemeinsam genutzten Speicher, konnte nur zugegriffen werden, oder modifiziert über diese Anweisung, wenn sich die CPU im user-Modus. Wenn es gab keine freien Adern, es würde lassen Sie schnell Weg und wieder auf ein system nennen. Das könnte die automatische Parallelisierung von Schleifen mit nur tausend Iterationen eine Leistung gewinnen.

    InformationsquelleAutor Omnifarious
Schreibe einen Kommentar