Der neue C++11 Standard Allgemeine Neuerungen und Nebenläufigkeit

Transkript

1 Der neue C++11 Standard Allgemeine Neuerungen und Nebenläufigkeit Eine Präsentation von Sascha Kopp für Parallele Programmierung (G. Fröhlich) an der Hochschule Darmstadt (h_da)

2 Inhalt 1.Verbreitung 2.Fokus 3.Allgemeine Sprachfeatures 4.Nebenläufigkeit 5.Vorteile 6.Nachteile 7.Alternativen 8.Quellen

3 Verbreitung GCC vollständig, wird default mit zusätzlichen GNU-Extensions ab GCC-5 Clang vollständig bis auf wenige Ausnahmen Intel C++/Linux größtenteils vollständig Intel C++/Windows Teils vollständig, Nebenläufigkeit vollständig, außer Thread-Local Storage Visual Studio (2013) Teils vollständig, Nebenläufigkeit vollständig, außer Thread-Local Storage

4 Fokus Produktivität Generalisierung Nebenläufigkeit

5 Auto Compilezeitbestimmung von Datentypen an Hand von Rückgabewerten auto x = getsomedata(); auto &x = getsomedata(); const auto x = getsomedata();

6 Default, Delete Festlegen, ob es einen (Default-)Konstruktor gibt Dieser muss also nicht extra definiert werden default erzeugt ihn delete löscht ihn class A{ public: } A() = default; class B{ public: } B() = delete;

7 constexpr Forcieren, dass eine Funktion oder Variable zur Compilezeit aufgelöst wird Compilieren schlägt fehl, wenn dies nicht möglich ist constexpr int add(int a, int b) { } return a+b; const result = add(1, 3);

8 Raw-Literals Stringsequenzen, die Escapesequenzen ignorieren Sequenz "" wird zu " in Raw-Literals std::string str = R"\No escapes/" std::string str2 = R"Value is ""true""!";

9 Datentypen fester Größe Interessant für Netzwerk- oder Embeddedanwendungen Least-Varianten zum sparen von Speicher Fast-Varianten zum schnelleren berechnen Unicode-Datentypen int8_t, int16_t, int32_t, int64_t char8_t, char16_t, char32_t

10 Static-Assert Ermöglicht das Testen von Bedingungen zur Compilezeit D.h. Vorabbestimmen, ob sich Code so verhält, wie man es möchte, solange er konstant/vorab berechenbar ist static_assert(sizeof(int)==4, "Int is not 32bit on this system");

11 Smartpointer Übernommen aus TR1 Automatische Speicherverwaltung std::unique_ptr<int> u = new int[300]; //Ersetzt auto_ptr, //unterstützt Arrays std::shared_ptr<t> s = new T(); //Teilbar mit anderen //Funktionen/Scopes std::weak_ptr<t> w(s); //Schwache Referenz erstellen //(nützlich für Cachesysteme) std::shared_ptr<t> sw = w.lock(); //Starke Referenz //erzeugen

12 STL-For Loops Iterieren über STL-Container Nicht verwechseln mit std::for_each(beg, end, func) std:vector<int> v = {1, 2, 3}; for ( auto i : v) { //Über Objektkopie dosomething(i); } for ( auto &i : v) { //Über Referenz dosomething(i); }

13 Lambda-Funktionen Inline-Definition von Funktionen optional optional [captures] (params) -> retvaltype { // code } [] Keine Übergabe [=] Kopieren [&] Referenzieren [obj] obj kopieren [&obj] obj referenzieren [this] this-pointer übernehmen [this, &obj] mischen von Verschiedenen Angaben auch möglich

14 Sonstiges Interne Änderungen am Speichersystem Optimierung für nebenläufige Aufgaben Garantiert das auf-/ bzw. absteigende Iterieren von STL-Containern Viele weitere Neuerungen bzgl. Templates Bspw. Variadic Templates, etc. Funktionen für Unicodebehandlung

15 Nebenläufigkeit 1.Grundlagen 2.Threads 3.Synchronisation 4.Thread-Local Storage 5.Atomics 6.Futures

16 Grundlagen C++11 verwendet eine vom Compiler bzw. Linker gebundene Threading-Bibliothek D.h. C++11-Threads sind Wrapper für solche U.a. muss deswegen zumindest mit GCC eine solche (hier: pthread) mitgelinkt werden g++ -o <Ausgabe> --std=c++11 -lpthread <Eingabe> --std=c++11 legt hierbei den Sprachdialekt fest und muss bei jedem C++11-Programm angegeben werden

17 Threads Threads erlauben das nebenläufige Abarbeiten von Aufgaben in einem Prozess C++11 definiert hierzu die Klasse std::thread Im Gegensatz zu betriebssystemspezifischen Implementationen erlaubt der Standard mehrere Eingabeparameter von unterschiedlichen Datentypen C++11-Threads starten bei Instanziierung

18 std::thread #include <thread> //Erzeugen eines Threads std::thread t(func, arg1, arg2,..., argn); std::ref(arg) //Parameter als Referenz t.join() //Warte auf Threadende t.detach() //Lösen des Threads //Warnung: Aktive Threadinstanzen, die ihr //Scope verlassen rufen std::terminate auf und //terminieren den Prozess, sofern diese nicht //gelöst wurden oder man ihr beenden abwartet

19 std::this_thread Enthält statische Funktionen, die für den aktuellen Thread gelten get_id() Threadid zurückgeben yield() Rechenzeit freigeben sleep_until(arg) Bis zu Zeitpunkt schlafen sleep_for(arg) Für angegebene Zeit schlafen

20 Synchronisation C++11 kennt folgende Synchronisationsmechanismen: Mutexe Bedingungsvariablen Semaphoren sind nicht Teil des Standards

21 Mutexe Mutexe schützen kritische Datenbereiche vor multiplen Zugriffen Dazu definiert C++11 mehrere Typen von Mutex-Sperrvariablen Hier wird allerdings lediglich std::mutex, der Basistyp, behandelt Weitere speziellere Varianten sind: std::timed_mutex std::recursive_mutex std::recursive_timed_mutex std::shared_mutex

22 std::mutex #include <mutex> std::mutex m; m.lock(); //critical section m.unlock(); { Std::lock_guard<std::mutex> _l(m); //critical section }

23 Bedingungsvariablen Bedingungsvariablen dienen als Synchronisationspunkte, um kritische Bereiche oder Ressourcen zu schützen Entgegengesetzt zu Mutexen, werden diese von anderen Threads benachrichtigt, wenn eine Ressource frei wird und ein oder mehrere wartende Threads geweckt Da Bedingungsvariablen an Bedingungen geknüpft sind ist es wichtig, diese nach dem wecken abzufragen und bedingt erneut zu warten, da wartende Threads eventuell extern durch das Betriebssystem geweckt werden könnten (Spurious Wakeup) und nicht, wie erwartet, durch andere Threads Hierzu gibt es std::condition_variable und für Spezielleres std::condition_variable_any (akzeptiert jeden Sperrvariablentyp)

24 std::condition_variable #include <condition_variable> #include <mutex> std::mutex m; //global std::condition_variable cv; //global std::unique_lock<std::mutex> _l(m); //Wrapper für while(!conditionmet) //Mutex cv.wait(_l);

25 std::condition_variable Veränderung signalisieren mit: cv.notify_one(); cv.notify_all();

26 Thread-Local Storage Abb. 1: Thread-Local Storage unter Microsoft Windows (Quelle: MSDN)

27 Thread-Local Storage Slotsystem für das Belegen und Anfordern threadlokalen Speichers Jedem Slot gehören mehrere Felder, die auf die eigentlichen Daten verweisen In C++11-Programmen werden thread-lokale Variablen über das thread_local Keyword spezifiziert und in der Regel im globalen Bereich deklariert Threads besitzen ihre eigenen privaten Kopien, dieser Variablen bzw. wird beim Zugriff in einen anderen Speicherbereich verwiesen Anwendung bspw. für Sitzungsinformationen oder Zufallszahlengeneratoren

28 std::atomic Atomare Variablen gehen sicher, dass keine inkonsistenten Zustände entstehen Alle Operationen (Zuweisen, In-/Dekrementieren, Herausladen, Vergleichen) sind atomar #include <atomic> std::atomic<int> aval(0); int val = aval; aval = val; aval++;

29 Futures Futures sind ein Mechanismus, der Synchronisationspunkte an Variablen bindet Aufgaben (Tasks) werden asynchron gestartet und das Ergebnis später, wenn es benötigt wird abgefragt Ist das Ergebnis noch nicht vorhanden, wird blockiert Alternativ ist es möglich ein Versprechen (Promise) abzugeben und einem Thread zu übergeben, der dann weiter arbeitet, sobald die benötigten Daten zur Verfügung stehen

30 Futures #include <future> std::future<t> f; //Enthält ein zukünftiges Ergebnis //Nicht blockierendes Aufrufen einer Funktion //bzw. Spawnen eines neuen Threads/Tasks f = std::async(std::launch::async, func, args...); T val = f.get(); //Blockierendes Abfragen //Teilen eines Futures für geteilte Verwendung std::shared_future<t> sf = f.share();

31 Futures #include <future> std::promise<t> p; //Enthält das Versprechen ein //Ergebnis zu liefern std::future<t> fp = p.get_future(); //Future //zurückliefern, dass das //Ergebnis erhalten wird p.set(val); //Das Versprechen erfüllen //fp wird also nicht mehr //blockieren

32 Vorteile Keine Verweise oder Marshalling von Daten notwendig, da Threads normale Parameter (int, char, etc.) annehmen und keine feste Form aufweisen müssen D.h. Funktionen selbst können auch als solche (nicht nur als Thread) aufgerufen werden und müssen nicht explizit angepasst werden Jede Instanz ist direkt an seine möglichen Funktionen gebunden (join, detach, etc.) Zugriff über gelinkte Threadingbibliothek auch möglich über native_handle Methode

33 Nachteile Keine Semaphoren Vergleichsweise weniger Funktionalität als bspw. boost Keine Threadpools Keine Möglichkeit einzelne Threads (unsauber) zu terminieren D.h. höherer Aufwand bei Planung

34 Alternativen Boost C++ Libraries C# Concurrency Library Java Concurrency Library

35 Quellen Abb. 1: dows/desktop/ms686749%28v=vs.85%29.aspx