Du befindest dich hier: FSI Informatik » Prüfungsfragen und Altklausuren » Prüfungen im Bachelor-Studium (1. - 5. Semester) » pfp » Aufgabe 1   (Übersicht)

Dies ist eine alte Version des Dokuments!


Aufgabe 1

  • a) Sequentieller Umstieg, Beschränkung der Parallelität.
  • b) Das Schalten einer Transition erfolgt atomar. (Hat jmd. (Gegen-)argumente für „Die Petri-Netze enthalten lebendige Transitionen“?)
  • c) Die parallale Effizienz ist 2. Der Speedup ist 16.

Aufgabe 2

Block 1
new CyclicBarrier(nThreads);
Block 2
// Lösung mit einzelnen Thread-Objekten auch denkbar
ExecutorService es = Executors.newFixedThreadPool(nThreads);
for (int i = 0; i < nThreads; i++) {
  GRunnable gr = new GRunnable(i, nThreads, barrier);
  es.execute(gr),
}
Block 3
es.shutdown();
es.awaitTermination(60, TimeUnit.SECONDS);
Block 4
for (int col = id; col < size; col += nThreads) {
  for (int row = 0; row < size; row++) {
    dest[row][col] = step(row, col);
  }
}
Block 5
if (barrier.await() == 0) { // alternativ auch if (id == 0)
  swap();
}
barrier.await();
Block 6
barrier.await(); // Eigentlich unnötig bei Nutzung eines ExecutorServices, oder?

Aufgabe 3

  • a)
  • b) Ein Pfeil von Q zu t1 (Gewicht 1) und ein Pfeil von t2 zu Q (Gewicht 2).

Aufgabe 4

  • a)
    • Zeile 27: Ja, weil AtomicInteger intern synchronisiert ist.
    • Zeile 34: Ja, weil jeder Thread nur die lokale Variable modifiziert (und synchronized(this) eh sinnlos ist).
    • Zeile 38: Nein, globalHits ist allen Threads gemein
  • b)
    • 14/46: Nein, weil i in #47 zur Berechnung benötigt wird.
    • 19/49: Ja, da v eine volatile Referenz ist und Spin (= aktives Warten) existent.
    • 22/52: Nein, denn ohne die Barriere bei 19/49 könnte in Thread 3 k=0 aufgrund fehlender Synchronisationspunkte bei der While-Schleife in #53 gelten ⇒ Falsche Ausgabe

Aufgabe 5

Ist aktuell eine Bonusaufgabe, daher zur Vermeidung von Plagiaten noch nicht veröffentlicht.

Aufgabe 6

  • a)
def first: List[Solution] => Solution = sols =>
  sols.foldLeft(List[Transition]())((acc, cur) => acc match {
    case Nil => cur
    case default => acc
  })
  • b)
case (s::ss, sol) if s == end => sol
case (s::ss, sol) if ss.contains(s) => helper(ss, sol)
    
// Unsicher! Bitte Kommentare/Ergänzungen/Verbesserungen
case (s::ss, sol) => {
  val next = passage(s)
  first(next.map((nextState, nextTransition) => helper(nextState::ss, sol ::: List(nextTransition)))))
}