Tweede zittijd - Academiejaar 2015-2016
3 september 2016
Naam:
Instructies
• Schrijf je naam op elk blad.
• Beantwoord de open vragen op de ruimte voorzien onder de vraag.
• Gebruik de achterkant van het blad indien je ruimte tekort komt. Indien je nog extra ruimte nodig hebt, verwijs dan duidelijk naar de extra toegevoegde bladzijden en noteer op deze bladzijden steeds je naam en het nummer van de vraag.
• Het examen is gesloten-boek.
• Je gebruikt enkel schrijfgerief en kladpapier; geen laptop, rekenmachine, tablet, gsm, etc. • Je dient zowel dit document als je kladpapier af te geven.
• Je krijgt 3 uur tijd om het examen op te lossen.
• Dit examen staat op 50 punten en telt mee voor 50% van je eindcijfer. • Veel succes!
Ruimte hieronder voorbehouden voor examinator.
Schrijftelijk examen /50
Schrijftelijk examen (50%) /20
Project (50%) /20
1
RPC (6pt)
Omschrijf het principe van Remote Procedure Call (RPC). Schets aan de hand van een diagram de afhandeling van een RPC call. Beantwoord ook de volgende vragen:
• Wat is het verschil tussen implicit en explicit typing?
• De meeste RPC systemen bieden ofwel at-least-once of at-most-once oproep semantiek aan. Leg het verschil uit a.d.h.v. het verschil in de fout-tolerantie maatregelen die ze aanbieden. • Wat is de rol van een interface definition language (IDL)?
2
Peer-to-peer systemen (6pt)
Peer-to-peer (P2P) systemen laten toe om op een gedistribueerde en fout-tolerante manier nodes te organiseren in een netwerk waar nodes symmetrisch zijn (in tegenstelling tot client-server systemen).
(a) Waarom zijn P2P systemen het meest geschikt voor onveranderlijke data?
(b) Geef één groot nadeel van een gecentraliseerd P2P systeem zoals Napster (vanuit een gedis-tribueerd standpunt).
(c) Flooding is een alternatief dat sommige van de problemen van gecentraliseerde P2P sys-temen verhelpt. Wat is een gekende techniek die gebruikt wordt om het propageren van queries te limiteren in een flooding netwerk?
(d) Gedistribueerde hashtabellen (DHT) garanderen lookup in een beperkt aantal hops (in tegenstelling tot flooding). Leg uit hoe een key gelinkt wordt aan een specifieke node in het netwerk bij een DHT die een ring mapping gebruikt, zoals bvb. Chord.
(e) In de meest eenvoudige implementatie van een DHT systeem houden nodes simpelweg hun voorganger en nakomeling bij. Leg kort uit wat voor probleem dit geeft als het netwerk groeit.
(f) Hoe voorkomt Chord dit probleem? Leg uit hoe lookup dan gebeurt a.d.h.v. een diagram.
3
Concurrency (6pt)
Gegeven is een circulaire implementatie van een queue met een vast aantal elementen. Zo’n implementatie bestaat uit een array van elementen en een size, count en first integer. Door de elementen circulair op te slaan in de array, kunnen we toevoegen en verwijderen in O(1).
1. De gegeven Queue-implementatie is niet thread-safe. Geef een scenario waarbij het fout gaat: teken de tijdslijn waarbij twee threads het ADT gebruiken en een concurrencybug zich voordoet. Welk soort type “race condition” is dit? Is dit de enige soort “race condition” die zich kan voordoen? Toon ook duidelijk wat de oorspronkelijke staat, de bedoelde eindstaat en de foute eindstaat van de ADT is.
2. Pas deze code nu zo aan dat ze thread-safe is. Geef hierbij duidelijk aan welke metho-den/welke lijnen code je aanpast (je mag de gewijzigde code gewoon rechts van de oor-spronkelijke code schrijven).
1 public class Queue<V> { 2 private V[] elements; 3 private int first; 4 private int count; 5 private int size; 6
7 // Maakt een nieuwe queue met size elementen 8 public Queue(int size) {
9 this.elements = (V[])(new Object[size]); 10 this.size = size;
11 this.count = 0; 12 }
13 // Verwijdert een element van de queue, als die niet leeg is 14 public V pop() {
15 if (isEmpty()) {
16 return null;
17 }
18 V el = elements[first]; 19 first = (first + 1) % size; 20 count--;
21 return el;
22 }
23 // Voegt een element toe aan de queue, als die niet vol is 24 public V push(V value) {
25 if (isFull()) {
26 return null;
27 }
28 int idx = (first + (++count - 1)) % size; 29 elements[idx] = value;
30 return value;
31 }
32 // Kijk of de queue leeg is 33 public boolean isEmpty() { 34 return count == 0;
35 }
36 // Kijkt of de queue vol is 37 public boolean isFull() { 38 return count == size;
39 }
40 //Geeft de grootte van de queue 41 public int size() {
42 return this.size; 43 }
44 // Toont aan hoe het ADT gebruikt wordt 45 public static void main(String[] args) {
46 Queue<Integer> q = new Queue<Integer>(5); // queue van 5 integers 47 for(int i = 0; i < 6; i++) {
48 System.out.println(q.push(i)); // 0 1 2 3 4 null
49 }
50 for (int i = 0; i < 6; i++) {
51 System.out.println(q.pop()); // 0 1 2 3 4 null
52 }
53 } 54 }
4
Fork/Join Parallelism (6pt)
Gegeven onderstaand Java-8 programma dat gebruik maakt van libraries en code die we gezien hebben in de les. Los volgende vragen op:
1. Geef de naam van het algoritme dat dit stuk code implementeert. 2. Welk concurrent paradigma wordt hiervoor gebruikt?
3. Leg in grote lijnen uit wat het algoritme doet.
4. Leg uit wat er zou gebeuren indien we de statements op lijn 21 en 22 zouden omwisselen. 5. Dit programma maakt gebruik van shared memory. Bij het gebruik van shared memory
kunnen zich data races voordoen. Kan dit bij het gegeven programma voorkomen? Ver-klaar je antwoord.
1 public class Class1 extends RecursiveAction{ 2 Node node;
3 int sumfromLeft; 4 int[] input output; 5
6 Class1(Node n, int sum, int[] in, int[] out){
7 node = n; sumfromLeft = sum; input = in; output = out;
8 }
9
10 protected void compute() { 11 if (node.isALeaf()){ 12 int lo = node.lo; 13 int hi = node.hi;
14 output[lo] = sumfromLeft + input[lo]; 15 for (int i = lo + 1; i < hi; i++) { 16 output[i] = output[i-1] + input[i];
17 }
18 } else {
19 Class1 left = new Class1(node.left, sumfromLeft, input, output); 20 Class1 right = new Class1(node.right, sumfromLeft +
node.left.sum, input, output); 21 left.fork(); 22 right.compute(); 23 left.join(); 24 } 25 } 26 27
28 final static ForkJoinPool fjPool = ForkJoinPool.commonPool(); 29
30 public static int[] execute(int[] input) { 31 int[] output = new int[input.length];
32 Node root = fjPool.invoke(new Class1(input,0,input.length)); 33 fjPool.invoke(new Class2(root, 0, input, output));
34 return output; 35 }
36 37 }
38 class Class2 extends RecursiveTask<Node> { 39 int[] input;
40 int lo, hi; 41
42 public Class2(int[] in, int l, int h) { 43 input = in; lo = l; hi = h;
44 }
45
46 protected Node compute() {
47 if( (hi - lo) < SEQUENTIAL_THRESHOLD) {
48 int ans = 0;
49 for(int i=lo; i < hi; ++i)
50 ans += input[i];
51 return new Node(null, null, ans, lo, hi);
52 } else{
53 int mid = (lo + hi)/2;
54 BuildTree left = new Class2(input, lo, mid); 55 BuildTree right = new Class2 (input, mid, hi);
56 left.fork();
57 Node rightNode = right.compute(); 58 Node leftNode = left.join();
59 int sum = leftNode.sum + rightNode.sum;
60 return new Node(leftNode, rightNode,sum , lo, hi);
61 }
62 }
63 }
5
Korte Vragen (6pt)
Hou je antwoord kort en bondig bij de volgende vragen. 1. Definieer Amdahl’s law.
2. Wat is een one-way hash function? Waarom is het nuttig voor cryptografie?
6
Waar/Niet waar (10pt)
Voor elk van de volgende uitspraken, kies waar of niet waar en leg kort uit waarom. Je krijgt 2 punten per juist antwoord, -1 punt per fout antwoord en 0 punten per blanco antwoord.
Waar / Niet waar a) Door enkel naar Lamport timestamps te kijken kunnen we niet bepalen welke gebeurtenissen causaal gerelateerd zijn en welke niet.
Waar / Niet waar b) Vector clocks is een algoritme om causaliteitsovertredingen te detecteren en het kan een totale orde van gebeurtenissen bepalen in een gedistribueerd systeem.
Waar / Niet waar c) Wanneer men een bericht zendt via UDP, zullen de client en server een handshake protocol aangaan.
Waar / Niet waar d) De “FLP impossibility result” toont aan dat er geen garantie is om altijd consensus te bekomen in een asynchroon gedistribueerd systeem
Waar / Niet waar e) De Diffie-Hellman-sleuteluitwisseling staat toe aan twee deelnemers een geheime sessiesleutel overeen te komen over een onbeveiligd netwerk, maar het biedt geen publieke-sleutelcryptografie aan.
7
Multiple-choice vragen (10 pt)
Omcirkel telkens het juiste antwoord. Je krijgt 2 punten per juist antwoord, -1 punt per fout antwoord en 0 punten per blanco antwoord.
7.1
Networking (2pt)
UDP is een voorbeeld van:
a) een netwerk protocol dat doet alsof het een toegewijd circuit heeft om datapakketten te versturen.
b) een virtual circuit protocol.
c) een transport layer protocol waarbij data pakketten ongeordend kunnen aankomen.
d) een transport layer protocol waarbij data pakketten herzonden worden als ze niet aankomen op hun bestemming.
7.2
Message Passing (2pt)
Welke concurrencyproblemen kunnen zich voordoen in programma’s geschreven met het actor model?
a) data races b) deadlocks c) lack of progress
d) geen van bovenstaande
7.3
Indirect Communication (2pt)
Zowel tuple spaces als publish/subscribe en message queuing zijn technieken om processen in-direct te laten communiceren. Welke ontkoppeling bieden ze aan?
a) Zowel tuple spaces als publish/subscribe bieden een gelijkaardige mate van ontkoppeling in tijd, ruimte en synchronisatie aan.
b) Zowel publish/subscribe als message queuing biedt een gelijkaardige mate van ontkoppe-ling in tijd en ruimte aan.
c) Zowel tuple spaces als message queuing biedt ontkoppeling in synchronisatie aan.
d) Tuple spaces bieden ontkoppeling in tijd maar geen ontkoppeling in ruimte omdat de in(t)operatie het consumerproces blokkeert.
7.4
Logische klokken (2pt)
Twee events, a en b, worden beschouwd als concurrent indien: a) ze op hetzelfde tijdstip plaatsvinden.
b) er geen causaal verband is zodat noch a → b noch b → a . c) ze zich voordoen op verschillende processoren.
d) event a en b verschillende Lamport timestamps hebben.
7.5
Security (2pt)
Enkel een digitale handtekening gecreëerd met publieke-sleutelcryptografie kan niet het vol-gende aanbieden:
a) authentication. b) integrity.
c) non-repudiation. d) confidentiality.
