Du befindest dich hier: FSI Informatik » Prüfungsfragen und Altklausuren » Prüfungen im Bachelor-Studium (1. - 5. Semester) » pfp » Aufgabe 1
Unterschiede
Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.
Nächste Überarbeitung | Vorherige ÜberarbeitungNächste ÜberarbeitungBeide Seiten, nächste Überarbeitung | ||
pruefungen:bachelor:pfp:loesungws15 [16.07.2016 16:09] – Angelegt :) Marcel[Inf] | pruefungen:bachelor:pfp:loesungws15 [19.07.2016 07:34] – Korrektur 1b Marcel[Inf] | ||
---|---|---|---|
Zeile 1: | Zeile 1: | ||
====== Aufgabe 1 ====== | ====== Aufgabe 1 ====== | ||
- | * a) Sequentieller Umstieg, Beschränkung der Parallelität. | + | * a) 1 und 4 |
- | * 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. | + | * b) 2 und 4 |
+ | Da nur nach gefragt ist, was den Speedup verbessern **könne**, ist 4 auch richtig, da es in manchen Fällen eine bessere Lastverteilung sichern könnte. (Mit dieser Logik wäre es auch richtig, auf die Frage, was den Speedup verschlechtern könne, dasselbe zu antworten. Denn kleinere Arbeitspakete können ab einem bestimmten Maße mehr Overhead und Synchronisationsaufwand nach sich ziehen.) | ||
+ | |||
+ | * c) 2 und 3 (siehe Seite 26 VL Folie: https:// | ||
====== Aufgabe 2 ====== | ====== Aufgabe 2 ====== | ||
- | == Block 1 == | + | * a) |
- | | + | <code=java> |
- | == Block 2 == | + | * b) |
- | // Lösung mit einzelnen Thread-Objekten auch denkbar | + | <code=java> |
- | ExecutorService es = Executors.newFixedThreadPool(nThreads); | + | boolean manageThreads(String linkUrl) { |
- | for (int i = 0; i < nThreads; i++) { | + | |
- | GRunnable gr = new GRunnable(i, | + | |
- | | + | |
- | | + | |
- | + | ||
- | == Block 3 == | + | |
- | es.shutdown(); | + | |
- | es.awaitTermination(60, TimeUnit.SECONDS); | + | |
- | + | ||
- | == Block 4== | + | |
- | for (int col = id; col < size; col += nThreads) { | + | |
- | | + | |
- | | + | |
- | } | + | |
} | } | ||
+ | else { | ||
+ | curThreads.decrementAndGet(); | ||
+ | return false; | ||
+ | } | ||
+ | } // END OF manageThreads | ||
+ | </ | ||
- | == Block 5 == | + | * c) |
- | | + | <code=java> |
- | | + | public void run() { |
+ | | ||
+ | curThreads.decrementAndGet(); | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | * d) | ||
+ | <code=java> | ||
+ | synchronized(visitedUrls) { | ||
+ | | ||
+ | | ||
+ | visitedUrls.add(linkUrl); | ||
} | } | ||
- | barrier.await(); | + | } |
- | + | </code> | |
- | == Block 6 == | + | |
- | barrier.await(); | + | |
- | ====== Aufgabe 3====== | + | ====== Aufgabe 3 ====== |
+ | {{: | ||
- | * a) {{:pruefungen: | + | Nicht gefragt, hier aber erwähnt: |
- | * b) Ein Pfeil von Q zu t1 (Gewicht 1) und ein Pfeil von t2 zu Q (Gewicht 2). | + | |
- | ====== Aufgabe 4====== | + | Beschränktheit: |
+ | |||
+ | Lebendigkeit: | ||
+ | |||
+ | ====== Aufgabe 4 ====== | ||
+ | * a) 3 | ||
+ | Nein ist nicht möglich, s wird bereits mit anderen Werten belegt, bevor das Programm parallel ausgeführt wird. Die Sichtbarkeit der in Zeile 25 festgelegten Werte ist gewährleistet (genauer [nicht VL-Stoff]: Es existiert im Allgemeinen eine Happens-Before Ordnung zwischen Code vor start() und dem Thread-Code.) | ||
+ | |||
+ | * b) 2 | ||
+ | Nein, " | ||
+ | |||
+ | * c) 4 | ||
+ | Nein, da die Threads wieder gejoint wurden. Das Programm ist somit nicht mehr parallel. Die Sichtbarkeit ist im (einzigen) Haupt-Thread gewährleistet (genauer [nicht VL-Stoff]: Es existiert im Allgemeinen eine Happens-Before Ordnung zwischen Thread-Code und Code nach einem erfolgreichen join()-Aufruf). | ||
+ | |||
+ | Was bringt hier, dass s als volatile deklariert ist? volatile wirkt sich nur auf die Referenz selbst aus, diese wird aber nie geändert, könnte also genauso gut finaln sein. | ||
+ | |||
+ | ====== Aufgabe 5 ====== | ||
* a) | * a) | ||
- | * Zeile 27: Ja, weil AtomicInteger intern synchronisiert ist. | + | < |
- | | + | def insert: (List[Int], Int) => List[Int] = (ls, v) => ls match { |
- | | + | case Nil => List(v) |
+ | case x::xs => { | ||
+ | | ||
+ | v :: x :: xs | ||
+ | } | ||
+ | else { | ||
+ | x :: insert(xs, v) | ||
+ | } | ||
+ | }</ | ||
+ | |||
+ | Alternativ: | ||
+ | < | ||
+ | def insert: | ||
+ | val p = ls.partition(_ <= v) | ||
+ | | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | Alternativ: | ||
+ | < | ||
+ | def insert: (List[Int], Int) => List[Int] = (ls, v) => | ||
+ | (for (l <- ls if l <= v) yield l) ::: (v :: (for (l <- ls if l > v) yield l)) | ||
+ | </ | ||
* b) | * 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 ====== | + | <code=scala> |
+ | def sort: List[Int] | ||
+ | ls.foldRight(List[Int]())((v, | ||
+ | // Alternativ zu " | ||
+ | // Nil: List[Int] | ||
+ | // Aber unbedingt mit Typangabe, sonst schlägt Scala' | ||
+ | </ | ||
- | Ist aktuell eine Bonusaufgabe, | + | * c) |
- | ====== Aufgabe 6 ====== | + | < |
+ | def sortAllWith: | ||
+ | sortFun => ls => for (cur <- ls) yield sortFun(cur) | ||
+ | </ | ||
+ | |||
+ | ====== Aufgabe 6 ====== | ||
* a) | * a) | ||
- | | + | < |
- | | + | def testInside: (Ellipse, Ellipse) |
- | case Nil => cur | + | (e1, e2) => (x, y) => isInside(e1, |
- | case default => acc | + | </code> |
- | }) | + | |
* b) | * b) | ||
- | case (s::ss, sol) if s == end => sol | + | < |
- | | + | def tupleStream: Stream[Double] => Stream[(Double, Double)] = s => |
- | + | (s.head, s.tail.head) #:: tupleStream(s.tail.tail) | |
- | // Unsicher! Bitte Kommentare/ | + | |
- | | + | // alternativ |
- | val next = passage(s) | + | (s(0), s(1)) #:: tupleStream(s.drop(2)) |
- | | + | </ |
- | } | + | |
+ | * c) | ||
+ | |||
+ | < | ||
+ | def monteCarlo: (Ellipse, Ellipse) => Int => Int = (e1, e2) => count => { | ||
+ | |||
+ | // Stream aus Punkten | ||
+ | | ||
+ | |||
+ | pointStream.take(count).par.filter(p | ||
+ | | ||
+ | // " | ||
+ | } | ||
+ | </ |