Software ubiquitärer Systeme

Transkript

1 Software ubiquitärer Systeme Produktlinien mit C++-Templates Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund 1

2 Inhalt Motivation Templates für Fortgeschrittene Policy-Based Design Synthesizing Objects Zusammenfassung 06.2 Produktlinien mit C++-Templates 2

3 Motivation Produktlinienkomponenten müssen wiederverwendbar sein statisch/dynamisch konfigurierbar vom Anwendungsfall unabhängig (generisch) formuliert Welche Programmiersprachenmechnismen für die generische Programmierung können genutzt werden? ist GP noch besser geeignet als OO oder AO? Analyse am Beispiel von C++ Templates [1, 2] 06.2 Produktlinien mit C++-Templates 3

4 Inhalt Motivation Templates für Fortgeschrittene Policy-Based Design Synthesizing Objects Zusammenfassung 06.2 Produktlinien mit C++-Templates 4

5 Fortgeschrittene Templates Template Metaprogramme Programmierung zur Übersetzungszeit: gezielte Code-Generierung Introspection statische Analyse der vorhandenen Typen... und es gibt noch viel mehr 06.2 Produktlinien mit C++-Templates 5

6 Template Metaprogramme (1) durch rekursive Template-Instanziierung und Template- Spezialisierung können zur Übersetzungszeit Fallunterscheidungen und Schleifen ausgeführt werden: Fac.h // Fac<I>: instanziiert Fac<I-1> rekursiv template<int I> struct Fac { enum { RES = I * Fac<I-1>::RES // Spezialisierung für <0>: terminiert die Meta-Schleife template <> struct Fac<0> { enum { RES = Produktlinien mit C++-Templates 6

7 Template Metaprogramme (2) zur Übersetzungszeit ausgeführte Berechnungen kosten zur Laufzeit nichts: main: pushl %ebp movl %esp, %ebp pushl $5040 main.cc pushl $.LC0 call #include <stdio.h> printf leave #include fac.h xorl %eax, %eax ret int main () { printf ("%d\n", Fac<7>::RES); // hier entsteht eine // Instanziierungskette! } im generierten Assembler-Code steht das Ergebnis (5040) bereits fest! mit Metaprogrammen lässt sich praktisch alles berechnen: die Sprache ist Turing-vollständig 06.2 Produktlinien mit C++-Templates 7

8 Introspection mittels Template-Spezialisierung und dem Overload- Resolution Mechanismus kann man zur Übersetzungszeit vieles über vorhandene Typen herausfinden, z.b.: template <typename Base> struct InheritDetector { typedef char (&no)[1]; typedef char (&yes)[2]; static yes test(base *); // Resultatsgröße ist 1 static no test(...); // Resultatsgröße ist 2 template <typename Derived, typename Base> struct Inherits { typedef Derived *DP; // sizeof ermittelt die Größe des Resultatsobjekts enum { RET = sizeof(inheritdetector<base>::test(dp())) == sizeof(inheritdetector<base>::yes) 06.2 Produktlinien mit C++-Templates 8

9 Inhalt Motivation Templates für Fortgeschrittene Policy-Based Design Synthesizing Objects Zusammenfassung 06.2 Produktlinien mit C++-Templates 9

10 Policy-Based Design [3] Problemfeld Entwurfsentscheidungen wie man es macht, macht man es falsch Lösungen können je nach Anwendungsfall mehr oder weniger (oder gar nicht) geeignet sein Entscheidung sollte nicht beim Entwickler einer Klasse liegen, sondern beim Anwender Ziel: Klassen konfigurierbar gestalten Schaffung einer Auswahlmöglichkeit für verschiedene Verhaltensweisen durch den Anwender 06.2 Produktlinien mit C++-Templates 10

11 Idee von Policy-based Design Klassen mit komplexem Verhalten werden in eine Host-Klasse und mehrere kleinere Policy-Klassen zerlegt jede Policy kapselt einen Belang der Host-Klasse Verbindung der komplexen Klasse mit den Policy-Klassen über C++ Templates Policies sind vom Benutzer der Klasse auswählbar der Benutzer kann also das Verhalten der Host-Klasse durch geeignete Auswahl von Policy-Klassen anpassen 06.2 Produktlinien mit C++-Templates 11

12 Beispiel: NewCreator... ist ein Klassen-Template, das neue Objekte erzeugt: template <class T> class NewCreator { public: static T *create() { return new T; }... Widget *w = NewCreator<Widget>::create(); NewCreator erzeugt alle Objekte mit new in manchen Fällen könnte anderes Verhalten erwünscht sein 06.2 Produktlinien mit C++-Templates 12

13 Beispiel: MallocCreator Alternative zum NewCreator MallocCreator fordert Speicher mit malloc() an Objekt wird mit Placement New in den Speicher gelegt template <class T> class MallocCreator { public: static T *create() { void *buf = malloc(sizeof(t)); if (!buf) return 0; // oder Exception werfen return new(buf) T; // placement new }... Widget *w = MallocCreator<Widget>::create(); 06.2 Produktlinien mit C++-Templates 13

14 Beobachtung MallocCreator und NewCreator besitzen dieselbe Schnittstelle beide verfügen über die Methode create(), die ein neues Objekt erstellen soll eine gemeinsame abstrakte Basisklasse, die die gemeinsame Schnittstelle manifestieren würde, gibt es aber nicht NewCreator lässt sich trotzdem im Quellcode durch MallocCreator ersetzen statische Polymorphie 06.2 Produktlinien mit C++-Templates 14

15 Der Begriff Policy Policies sind Schnittstellen für konfigurierbare Belange einer Klasse Policy-Klassen implementieren die von der Policy vorgegebene Schnittstelle Beispiel: Creation Policy kapselt das Erstellen von neuen Objekten Schnittstelle besteht aus der Methode create(), welche ein neues Objekt erzeugen soll Templates NewCreator und MallocCreator sind mögliche Policy-Klassen; es sind aber noch weitere denkbar 06.2 Produktlinien mit C++-Templates 15

16 Verwenden der Policy Policy-Klassen werden bei der Übersetzung mittels Template-Parameter in die Host-Klasse eingebunden Beispiel WidgetManager: template <class CreationPolicy> class WidgetManager { public: void newwidget() { Widget *w = CreationPolicy::create();... } Produktlinien mit C++-Templates 16

17 Auswahl der Policy-Klasse Anwender von WidgetManager können die Creation Policy nun auswählen: Mit NewCreator: typedef WidgetManager<NewCreator<Widget> > WM; oder mit dem MallocCreator: typedef WidgetManager<MallocCreator<Widget> > WM; Problem: Man muss immer Widget mit angeben, obwohl klar ist, dass der WidgetManager Widgets anlegen will 06.2 Produktlinien mit C++-Templates 17

18 Template Template Parameter Lösung: Host-Klasse bekommt die Policy-Klasse als Template Template Parameter übergeben: einfacher zu lesen weniger fehleranfällig: Benutzer gibt den Objekttyp nicht selbst an flexibler: WidgetManager kann auch andere Objekte erzeugen template <template <class> class CreationPolicy> class WidgetManager { public: void newwidget() { Widget *w = CreationPolicy<Widget>:create();... }... // jetzt kompakter und einfacher: typedef WidgetManager<NewCreator> WM; 06.2 Produktlinien mit C++-Templates 18

19 Weitere Möglichkeiten die Struktur der Host-Klasse ist durch Erben von der Policy-Klasse erweiterbar Host erbt Member-Variablen von den Policies Policies können zusätzliche Methoden in die Host-Klasse einbringen ( Enriched Policies ) Policies sind so nicht nur auf Verhalten beschränkt 06.2 Produktlinien mit C++-Templates 19

20 Entwurf einer Klasse mit Policies Auswahl der Policies Entscheiden, welche Belange durch Policies realisiert werden Schwierige Entwurfsentscheidungen in Policies auslagern bei mehreren Policies: möglichst orthogonale Semantik definieren Konsequenzen Policies müssen beim Entwurf der Host-Klasse festgelegt werden! nachträgliche Einführung zusätzlicher Policies schwierig (im Gegensatz zum Erweitern durch Policy-Klassen) Policy ist im Code der Host-Klasse verankert - join points sind damit explizit vorgegeben - keine gute Möglichkeit zur Modularisierung quer schneidender Belange 06.2 Produktlinien mit C++-Templates 20

21 Fazit Policy-based Design... erlaubt die getrennte Realisierung konfigurierbarer Belange in Form von Policies ermöglicht flexible Klassen, deren Verhalten der Anwender an seine Bedürfnisse anpassen kann basiert auf Sprachelementen von C++ - Templates - Template Template Parameter ein größeres Anwendungsbeispiel jetzt: Synthesizing Objects 06.2 Produktlinien mit C++-Templates 21

22 Inhalt Motivation Templates für Fortgeschrittene Policy-Based Design Synthesizing Objects Zusammenfassung 06.2 Produktlinien mit C++-Templates 22

23 Synthesizing Objects [4] Welche Programmiersprachenmechanismen für die generische Programmierung können genutzt werden? C++ Templates! Wie beschreibt man Variabilität auf einem problemadequaten abstrakten Niveau? Merkmalmodelle! Merkmal-getriebene Generierung mittels Templates 06.2 Produktlinien mit C++-Templates 23

24 Beispielszenario - Merkmale eine Familie von Listen-Klassen List [ElementType] Ownership Morphology LengthCounter Tracing external reference owned reference copy polymorphic monomorphic [LengthType]... int short long 06.2 Produktlinien mit C++-Templates 24

25 Beispielszenario - Architektur... in Form einer (erweiterten) funktionalen Hierarchie optionale Merkmale werden optionale obere Schichten weitere Variabilität durch Konfigurierbarkeit der Schichten Basisschicht mit Konfigurationswissen Tracing Tracing Layer Layer Counter Counter Layer Layer BasicList BasicList TracedList LenList PtrList Config Config ElementType : [ElementType] Destroyer : EmptyDestroyer ElementDestroyer TypeChecker : DynamicTypeChecker EmptyTypeChecker Copier : PolymorphicCopier MonomorphicCopier EmptyCopier LengthType : int short long... ReturnType 06.2 Produktlinien mit C++-Templates 25

26 Beispielszenario - Architektur... in Form einer (erweiterten) funktionalen Hierarchie optionale Merkmale werden optionale obere Schichten weitere Variabilität durch Konfigurierbarkeit der Schichten Basisschicht mit Konfigurationswissen Tracing Tracing Layer Configuration Layer TracedList Repository: Stellt Konfigurationsinformationen in Counter Counter Layer Form von Typen zur Verfügung. Layer LenList Minimiert Abhängigkeiten zwischen den Schichten. BasicList BasicList PtrList Config Config ElementType : [ElementType] Destroyer : EmptyDestroyer ElementDestroyer TypeChecker : DynamicTypeChecker EmptyTypeChecker Copier : PolymorphicCopier MonomorphicCopier EmptyCopier LengthType : int short long... ReturnType 06.2 Produktlinien mit C++-Templates 26

27 PtrList (1) Daten und Typen template <class Config_> class PtrList { public: // Config als Member-Typ zur Verfügung stellen: typedef Config_ Config; private: // Weitere Typen aus dem Configuration Repository: typedef typename Config::ElementType ElementType; typedef typename Config::SetHeadElementType SetHeadElementType; typedef typename Config::ReturnType ReturnType; // Diese Typen repräsentieren Policies! typedef typename Config::Destroyer Destroyer; typedef typename Config::TypeChecker TypeChecker; typedef typename Config::Copier Copier; private: // Datenelemente ElementType *head_; // jede Liste speichert einen Zeiger auf 1 Element ReturnType *tail_; // weitere Elemente stecken in der Liste tail_ public: // Methoden (siehe nächste Folie) Produktlinien mit C++-Templates 27

28 PtrList (2) - Methoden // Konstruktor: erzeugt eine neue Liste PtrList(SetHeadElementType &h, ReturnType *t=0) : head_(0), tail_(t) { sethead(h); } // Destruktor: ggf. das referenzierte Element löschen ~PtrList() { Destroyer::destroy (head_); } // Initialisierung des Elements: ggf. Typprüfung und Kopie void sethead(setheadelementtype &h) { TypeChecker::check(h); head_ = Copier::copy(h); } // Setter und Getter Funktionen ElementType &head() { return *head_; } void settail(returntype *t) { tail_ = t; } ReturnType *tail() const { return tail_; } wozu eigentlich SetHeadElementType&? je nachdem, ob die Elemente kopiert werden, ist das ElementType& oder const ElementType& 06.2 Produktlinien mit C++-Templates 28

29 Policies (1) - Destroyer template <class ElementType> struct ElementDestroyer { static void destroy(elementtype *e) { delete e; // Heap speicher wird freigegeben, Destruktor ausgeführt } template <class ElementType> struct EmptyDestroyer { static void destroy(elementtype *e) { // NICHTS! } der ElementDestroyer muss verwendet werden, wenn die Liste Elemente vor dem Einfügen kopiert Aufrufe von EmptyDestroyer::destroy() kann der Optimierer komplett eliminieren! 06.2 Produktlinien mit C++-Templates 29

30 Policies (2) - TypeChecker template <class ElementType> struct DynamicTypeChecker { static void check(const ElementType &e) { // Typüberprüfung mittels RTTI zur Laufzeit (Debug-Modus) assert(typeid(e)==typeid(elementtype)); } template <class ElementType> struct EmptyTypeChecker { static void check(const ElementType &e) { // NICHTS } der DynamicTypeChecker sorgt dafür, dass alle Elemente der Liste den selben Typ haben (monomorphic list)... und noch eine Klasse, die NICHTS tut Produktlinien mit C++-Templates 30

31 Policies (3) - Copier template <class ElementType> struct PolymorphicCopier { static ElementType *copy(const ElementType &e) { return e.clone(); // Kopieren mittels einer virtuellen Methode } template <class ElementType> struct MonomorphicCopier { static ElementType *copy(const ElementType &e) { return new ElementType(e); // Kopieren mittels Copy-Konstruktor } template <class ElementType> struct EmptyCopier { static ElementType *copy(elementtype &e) { return &e; // liefert einfach das Original } 06.2 Produktlinien mit C++-Templates 31

32 Zwischenfazit Traits & Policies unser PtrList Template ist hochgradig generisch: variable Aktivitäten werden durch Policies realisiert der Zugriff auf die richtige Policy-Klasse wird über das Configuration Repository gesteuert: eine Traits-Klasse was sind Traits und Policies? Traits represent natural additional properties of a template parameter Policies represent configurable behavior for generic functions and types D. Vandevoorde and M. Josuttis C++ Templates: The Complete Guide 06.2 Produktlinien mit C++-Templates 32

33 LenList optionale Wrapper Klasse 1 template <class BaseList> class LenList : public BaseList { // Template Parameter wird Basisklasse public: // Ermittlung des Configuration Repository typedef typename BaseList::Config Config; private: // Ermittlung weiterer Typen aus dem Configuration Repository: typedef typename Config::ElementType ElementType; typedef typename Config::SetHeadElementType SetHeadElementType; typedef typename Config::ReturnType ReturnType; typedef typename Config::LengthType LengthType; private: // Datenelemente LengthType length_; // Anzahl der Elemente in der Liste public: // Methoden: Erweiterungen zur Verwaltung der Länge... LenList(SetHeadElementType &h, ReturnType *t=0) : BaseList(h,t), length_(computedlength()) {} void settail(returntype *t) { BaseList::setTail(t); length_ = computedlength(); } const LengthType &length() const { return length_; } LengthType computedlength() const { return tail()? tail()->length()+1 : 1; } 06.2 Produktlinien mit C++-Templates 33

34 TracedList optionaler Wrapper 2 template <class BaseList> class TracedList : public BaseList { // Template Parameter wird Basisklasse public: // Ermittlung des Configuration Repository typedef typename BaseList::Config Config; private: // Ermittlung weiteree Typen aus dem Configuration Repository: typedef typename Config::ElementType ElementType; typedef typename Config::SetHeadElementType SetHeadElementType; typedef typename Config::ReturnType ReturnType; public: // Methoden: Wrapper zur Ausgabe des Funktionsnamens TracedList(SetHeadElementType &h, ReturnType *t=0) : BaseList(h,t) {} void sethead(setheadelementtype &h) { cout << "sethead(" << h << ")" << endl; BaseList::setHead(h); } ElementType &head() { cout << "head()" << endl; return BaseList::head(); } void settail(returntype *t) { cout << "settail(t)" << endl; BaseList::setTail(t); } 06.2 Produktlinien mit C++-Templates 34

35 Konfigurierung Variante 1... erfolgt durch Anlegen eines Configuration Repository struct TracedCopyMonoPersonLenListConfig { // typedefs, die von den Komponenten benötigt werden typedef Person ElementType; typedef const ElementType SetHeadElementType; typedef int LengthType typedef ElementDestroyer<ElementType> Destroyer; typedef DynamicTypeChecker<ElementType> TypeChecker; typedef MonomorphicCopier<ElementType> Copier; // PtrList wird in LenList und TracedList verpackt typedef TracedList< LenList< PtrList<TracedCopyMonoPersonLenListConfig> > > ReturnType; // und nun noch ein kürzerer Name... typedef TracedCopyMonoPersonLenListConfig::ReturnType MyList1; 06.2 Produktlinien mit C++-Templates 35

36 Konfigurierung Variante 1... erfolgt durch Anlegen eines Configuration Repository struct TracedCopyMonoPersonLenListConfig { // typedefs, die von den Komponenten benötigt werden typedef Person ElementType; typedef const ElementType SetHeadElementType; typedef int LengthType typedef ElementDestroyer<ElementType> Destroyer; typedef DynamicTypeChecker<ElementType> TypeChecker; typedef MonomorphicCopier<ElementType> Copier; // PtrList wird in LenList und TracedList verpackt typedef Weg der Konfigurationsinformationen TracedList< LenList< PtrList<TracedCopyMonoPersonLenListConfig> > > ReturnType; // und nun noch ein kürzerer Name... typedef TracedCopyMonoPersonLenListConfig::ReturnType MyList1; 06.2 Produktlinien mit C++-Templates 36

37 Konfigurierung Variante 2... oder z.b. so: struct RefPolyPersonListConfig { // typedefs, die von den Komponenten benötigt werden typedef Person ElementType; typedef ElementType SetHeadElementType; typedef EmptyDestroyer<ElementType> Destroyer; typedef EmptyTypeChecker<ElementType> TypeChecker; typedef EmptyCopier<ElementType> Copier; // PtrList wird direkt verwendet typedef PtrList<RefPolyPersonListConfig> ReturnType; // und nun noch ein kürzerer Name... typedef RefPolyPersonListConfig::ReturnType MyList2; 06.2 Produktlinien mit C++-Templates 37

38 Zwischenfazit mit Hilfe von unterschiedlichen Configuration Repositories lassen sich 24 verschiedene Listentypen erzeugen wer erstellt die Configuration Repositories? der Listen-Entwickler - bei 24 Varianten gerade noch machbar, bei tausenden nicht! der Anwender der Listen - mühsam und fehlerträchtig - viel Wissen über interne Strukturen nötig Antwort: Konfigurierung durch den Anwender auf abstrakter Ebene mit Hilfe der Merkmale das Configuration Repository muss generiert werden; das ist die Aufgabe des Configuration Generator - Template Metaprogrammierung! 06.2 Produktlinien mit C++-Templates 38

39 Der Configuration Generator (1)... erwartet Merkmale als Eingabe: enum Ownership { ext_ref, own_ref, cp enum Morphology { mono, poly enum CounterFlag { with_counter, no_counter enum TracingFlag { with_tracing, no_tracing... basiert auf einem kleinen Hilfs-Template: template <bool cond, class ThenType, class ElseType> struct IF { typedef ThenType RET; // Spezialisierung für false template <class ThenType, class ElseType> struct IF<false, ThenType, ElseType> { typedef ElseType RET;... und wird so benutzt: ganz einfach! typedef LIST_GENERATOR<Person, ext_ref, poly>::ret MyList3; 06.2 Produktlinien mit C++-Templates 39

40 Der Configuration Generator (2) template < class ElementType_ = int, Ownership ownership = cp, Morphology morphology = mono, CounterFlag counterflag= no_counter, TracingFlag tracingflag = no_tracing, class LengthType_ = int> class LIST_GENERATOR { public: typedef LIST_GENERATOR<ElementType_, ownership,...> Generator; private: // Konfigurierungslogik wird durch IFs ausgedrückt... typedef IF<ownership==cp ownership==own_ref, ElementDestroyer<ElementType_>, EmptyDestroyer<ElementType_> >::RET Destroyer_; typedef IF<morphology==mono, DynamicTypeChecker<ElementType_>, EmptyTypeChecker<ElementType_> >::RET TypeChecker_;... typedef PtrList<Generator> List; typedef IF<counterFlag==with_counter, LenList<List>, List>::RET List_with_counter_or_not; typedef IF<tracingFlag==with_tracing, TracedList<List_with_counter_or_not>, List_with_counter_or_not>::RET List_with_tracing_or_not; // öffentliche Typen... (nächste Seite) 06.2 Produktlinien mit C++-Templates 40

41 Der Configuration Generator (3) public: // öffentliche Typen typedef List_with_tracing_or_not RET; struct Config { typedef ElementType_ ElementType; typedef SetHeadElementType_ SetHeadElementType;... typedef RET ReturnType; da Config jetzt eine generierte Klasse im Generator ist, muss die PtrList Klasse minimal angepasst werden. template <class Generator> class PtrList { public: typedef typename Generator::Config Config; // der Rest wie gehabt Produktlinien mit C++-Templates 41

42 Inhalt Motivation Templates für Fortgeschrittene Policy-Based Design Synthesizing Objects Zusammenfassung 06.2 Produktlinien mit C++-Templates 42

43 Zusammenfassung C++ Templates bilden das notwendige Handwerkszeug, um mit C++ generisch zu programmieren Merkmalmodelle bilden das Handwerkszeug, um Variabilität von Produktlinien zu beschreiben in Synthesizing Objects verbinden U. Eisenecker und K. Czarnecki beide Techniken Trennung der Belange durch Configuration Repositories und Configuration Generators Anwendung der Template-Metaprogrammierung und von Policy-Based Design der Ansatz erfordert, dass man die Nachteile der Programmierung mit C++ Templates in Kauf nimmt Fehlermeldungen, Übersetzungszeiten, Syntax, Produktlinien mit C++-Templates 43

44 Literatur [1] D. Vandevoorde, N.M. Josuttis, C++ Templates: The Complete Guide. Addison-Wesley, 2003, ISBN [2] The C++ Standard BS ISO/IEC 14882:2003 (Second Edition). John Wiley & Sons, Ltd., 2003, ISBN [3] A. Alexandrescu, Modern C++ Design Generic Programming and Design Patterns Applied. Addison-Wesley, 2002, ISBN [4] K. Czarnecki und U. Eisenecker, Synthesizing Objects. Concurrency: Practice and Experience, John Wiley & Sons, Ltd Produktlinien mit C++-Templates 44