Muesli
 All Classes Namespaces Files Functions Typedefs Enumerations
process.h
1 /*
2  * process.h
3  *
4  * Author:
5  *
6  * -------------------------------------------------------------------------------
7  *
8  * The MIT License
9  *
10  * Copyright 2014 Steffen Ernsting <s.ernsting@uni-muenster.de>,
11  * Herbert Kuchen <kuchen@uni-muenster.de.
12  *
13  * Permission is hereby granted, free of charge, to any person obtaining a copy
14  * of this software and associated documentation files (the "Software"), to deal
15  * in the Software without restriction, including without limitation the rights
16  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
17  * copies of the Software, and to permit persons to whom the Software is
18  * furnished to do so, subject to the following conditions:
19  *
20  * The above copyright notice and this permission notice shall be included in
21  * all copies or substantial portions of the Software.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
24  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
26  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
28  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
29  * THE SOFTWARE.
30  *
31  */
32 
33 #pragma once
34 
35 #include <ctime>
36 
37 #include "muesli.h"
38 
39 namespace msl {
40 
41 namespace detail {
42 
43 // abstrakte Oberklasse aller Taskparalleler Skelette
44 class Process
45 {
46 
47 public:
48 
49  // Konstruktor: numOfEntrances/numOfExits vordefiniert mit 1
50  // (nur Farm hat i.d.R. mehrere)
51  Process();
52 
53  virtual ~Process();
54 
55  std::vector<ProcessorNo> getSuccessors() const;
56 
57  std::vector<ProcessorNo> getPredecessors() const;
58 
59  std::vector<ProcessorNo> getEntrances() const;
60 
61  std::vector<ProcessorNo> getExits() const;
62 
63  // Methoden zum Verwalten der Tags und zur Prozesssteuerung
64  int getReceivedStops() const;
65 
66  int getReceivedTT() const;
67 
68  void addReceivedStops();
69 
70  void addReceivedTT();
71 
72  void resetReceivedStops();
73 
74  void resetReceivedTT();
75 
76  int getNumOfPredecessors() const;
77 
78  int getNumOfSuccessors() const;
79 
80  int getNumOfEntrances() const;
81 
82  int getNumOfExits() const;
83 
84  // Soll der Empfaenger einer Nachricht per Zufall ausgewaehlt werden, kann mit Hilfe dieser
85  // Methode der Seed des Zufallsgenerators neu gesetzt werden. Als Seed wird die Systemzeit
86  // gewaehlt.
87  void newSeed();
88 
89  // jeder Prozess kann einen zufaelligen Empfaenger aus seiner successors-Liste bestimmen
90  // Den Seed kann jeder Prozess mit newSeed() auf Wunsch selbst neu setzten.
91  inline ProcessorNo getRandomReceiver();
92 
93  // jeder Prozess kann den Nachrichtenempfaenger zyklisch aus seiner successors-Liste bestimmen.
94  inline ProcessorNo getNextReceiver();
95 
96  // jeder Prozess kann den Nachrichtenempfaenger zyklisch aus seiner successors-Liste bestimmen.
97  ProcessorNo getReceiver();
98 
99  // jeder Prozessor kann den Empfaenger seiner ersten Nachricht frei waehlen. Dies ist in
100  // Zusammenhang mit der zyklischen Empfaengerwahl sinnvoll, um eine Gleichverteilung der
101  // Nachrichten und der Prozessorlast zu erreichen. Wichtig ist dies insbesondere bei einer
102  // Pipe von Farms.
103  void setNextReceiver(int index);
104 
105  // zeigt an, ob der uebergebene Prozessor in der Menge der bekannten Quellen ist, von denen
106  // Daten erwartet werden. Letztlich wird mit Hilfe dieser Methode und dem predecessors-array
107  // eine Prozessgruppe bzw. Kommunikator simuliert. Kommunikation kann nur innerhalb einer
108  // solchen Prozessgruppe stattfinden. Werden Nachrichten von einem Prozess ausserhalb dieser
109  // Prozessgruppe empfangen fuehrt das zu einer undefinedSourceException. Damit sind die Skelette
110  // deutlich weniger fehleranfaellig. Auf die Verwendung der MPI-Kommunikatoren wurde aus Gruenden
111  // der Portabilitaet bewusst verzichtet.
112  bool isKnownSource(ProcessorNo no) const;
113 
114  // >> !!! Der Compiler kann moeglicherweise den Zugriff auf folgende virtuelle Methoden
115  // >> optimieren, wenn der Zugriff auf diese statisch aufgeloest werden kann. Ansonsten
116  // >> wird der Zugriff ueber die vtbl (virtual table) einen geringen Performanceverlust
117  // >> bedeuten ==> ggf. ueberdenken, ob das "virtual" wirklich notwendig ist... !!!
118 
119  // Teilt einem Prozess mit, von welchen anderen Prozessoren Daten empfangen werden koennen.
120  // Dies sind u.U. mehrere, z.B. dann, wenn eine Farm vorgelagert ist. In diesem Fall darf
121  // der Prozess von jedem worker Daten entgegennehmen.
122  // @param p Array mit Prozessornummern
123  // @param length arraysize
124  virtual void setPredecessors(const std::vector<ProcessorNo>& p);
125 
126  // Teilt einem Prozess mit, an welche anderen Prozessoren Daten gesendet werden koennen.
127  // Dies sind u.U. mehrere, z.B. dann, wenn eine Farm nachgelagert ist. In diesem Fall darf
128  // der Prozess an einen beliebigen worker Daten senden.
129  // @param p Array mit Prozessornummern
130  // @param length arraysize
131  virtual void setSuccessors(const std::vector<ProcessorNo>& p);
132 
133  virtual void start() = 0;
134 
135  virtual void show() const = 0;
136 
137 protected:
138 
139  // Prozess empfaengt von mehreren Prozessoren
140  std::vector<ProcessorNo> predecessors;
141  // Prozess sendet an mehrere Prozessoren
142  std::vector<ProcessorNo> successors;
143  // Skelett hat mehrere Entrances
144  std::vector<ProcessorNo> entrances;
145  // Skelett hat mehrere Exits
146  std::vector<ProcessorNo> exits;
147  // size of predecessors array
148  int numOfPredecessors;
149  // size of successors array
150  int numOfSuccessors;
151  int numOfEntrances;
152  int numOfExits;
153 
154  // fuer Zeitmessungen
155  //double processBeginTime, processEndTime, processSendTime, processRecvTime;
156 
157  // counter fuer empfangene Tags
158  // = 0
159  int receivedStops;
160  // = 0
161  int receivedTT;
162 
163  // Dieses Flag wird benutzt um herauszufinden, ob ein Prozessor an einem bestimmten
164  // Prozess beteiligt ist oder nicht. Jedes Skelett wird auf eine bestimmte Prozessor-
165  // menge abgebildet. Anhand seiner eigenen Id kann jeder Prozessor feststellen, ob er
166  // Teil eines bestimmten Skeletts ist (finished=false) oder eben nicht (finished=true).
167  // Anhand des Zustands dieser Variable wird der Programmablauf gesteuert und parallelisiert.
168  bool finished;
169 
170 private:
171 
172  // fuer die interne Berechnung des Empfaengers der naechsten
173  // Nachricht; Für die zyklische Bestimmung des Nachfolgers
174  int nextReceiver;
175 
176 };
177 
178 }
179 
180 }
181 
182 #include "../../src/process.cpp"
Definition: process.h:44
Contains global definitions such as macros, functions, enums and classes, and constants in order to c...
int ProcessorNo
Typedef for process numbers.
Definition: muesli.h:107