Übung 4: Parallel Lua, Map-Reduce Tutorial

In dieser Übung findet eine erste Einführung in die Programmierung von parallelen Systemen nach dem Map & Reduce Modell statt.

Vorbereitung und Verwendung

Es wird die parallele LuaJit VM lvm für das jeweilige eigene Betriebssystem benötigt
- Momentan steht lvm für die Betriebssysteme Linux 32bit, Linux 64bit, Solaris 32bit, Windows 32bit und MacOS X 64bit zur Verfügung. Da Microsoft Windows zu keinem guten Informatikkonzept kompatibel ist kann es dort zu funktionalen Abweichungen und Einschränkungen von lvm kommen → lvm
- Lua/Csp Programme können direkt von der Konsole ausgeführt werden:
```
# lvm myprog.lua
```
- Die Programme (oder Teile davon) können ebenso in diesem Notebook ausgeführt werden wenn lvm mit einem Web Shell Wrapper gestartet wird (lokaler Rechner, Konsole):
```
# lvm weblvm.lua
Service thread 2 started.
[2@1592562880] HTTP server (2) listening to http://0.0.0.0:4610
Monitor thread 4 started.
[4@1592562880] HTTP server (4) listening to http://0.0.0.0:4611
```
- Diese Variante erlaubt das schrittweise Erlernen von Lua/Csp.
- Alle Code Snippets in diesem Notebook haben dann den gleichen Ausführungskontext (d.h. globale Variablen und Funktionen können von den einzelnen Snippets geteilt werden!)
- Dieser geteilte Kontext kann aber auch zu Problemen führen und bei Fehlern in parallelen Prozessen können Geisterprozesse übrig bleiben die nicht beendet werden können
- Ein Neustart des lvm Web Wrappers kann daher hin und wieder notwendig werden!. Das Notebook muss dann nicht neu geladen werden und funktioniert sofort nach dem Neustart von lvm wieder. Nur der globale VM Kontext ist wieder "leer"!
- Die Konsolenausgabe (mittels der print Anweisung) bei der Ausführung eines Programabschnitts wird automatisch weitergeleitet und hier angezeigt. Es kann aber nach einer gewissen Zeit erforderlich werden diese automatische Ausgabeweiterleitung wieder durch Drücken des Refresh Buttons anzustoßen (rechts an der jeweiligen Ausgabekonsole hier im Notebook)
- Jedes Codesnippet hat seine eigene Ausgabekonsole!
- Es kann sein dass in Worker Prozessen die print Ausgabe nicht hier im Code Snippet Konsolenfenster angezeigt wird (aber in der Terminalkonsole wo weblvm ausgeführt wird).

Es wird das aes.lua Modul benötigt. Ab lvm 1.1.16 integriert, ansonsten muss die Datei sich im gleichen Verzeichnis befinden wie weblvm.lua.

Falls es einen segfault Fehler bei der Ausührung mittels lvm weblvm.lua gibteinfach den Code in eine Datei exportieren (erster Button rechts im Codeeditor) und direkt mit lvm ausführen.

Partitionierung

Das lvm Modul parallel kann verwendet werden um selbstsynchronisierende parallele Datenverarbeitung von partitionierbaren Datensätzen nach dem Map & Reduce (MaR) Prinzip zu ermöglichen, also einer Datenverarbeitungskette (Pipeline). Im Gegensatz zum CSP Modell gibt es keine explizite Interprozesskommunikation zwischen einzelnen parallel ausgeführten Berechnungsprozessen. Daher kann die MaR Architektur eher als Datenpfadparallelität verstanden werden.

Folgende Bedingungen müssen erfüllt sein:

Ein Datensatz D kann in unabhängige Teilsätze {d}ⁱ zerlegen
Es gibt eine Berechnungsfunktion f(x):x → y die auf Fraktionen oder einzelne Elemente des Datensatzes angewendet werden kann
Es gibt i.A. eine Kette von Berechnungsfunktionen f(g(h(...(x)))) : x → y
Die Teilberechnungen sind vertikal unabhängig, horizonttal strikt sequenziell.
Es gibt (implizit) keinen geteilten Speicher, d.h. alle Ein- und Ausgabedaten werden kopiert! Das ermöglicht aber auch die verteilte Anwendung (ohne kommunikationsintensiven verteilten geteilten Speicher).
Jedoch können aus dem Csp Modul Shared Memory Matrizen Matrix an die Arbeitsprozesse weitergegeben werden (als Referenz, nicht Kopie). Veränderung dieser Matrizen in einem Prozess ist in den anderen Prozessen daher sichtbar.

Das lvm MaR Modul definiert eine parallele Berechnung als Sequenz von synchronisierten Operationen (horizontal Verabeitungskette). Dabei wird eine folgende Operation erst dann ausgeführt wenn die vorherige terminiert ist.

Es gibt folgende Operationen:

time() startet oder stoppt einen Zeitmesser;
map(worker,init) partitioniert und verteilt die Eingabedatenmenge auf options.workers parallele Prozesse die jeweils die worker Funktion ausführen, das Ergebnis besitzt die gleiche Dimensionalität wie die Eingabedaten, aber u.U. eine andere Typsignatur;
- init ist eine optionale Funktion die beim Start des Worker Prozesses aufgerufen wird;
- Wenn in den options mapchunks=false gesetzt wird (Standardeinstellung), dann bekommt die worker Funktionen nur ein Datenelement, ist mapchunks=true dann bekommt die worker Funktion die gesamte Partition und muss sie sleber iterieren.
- mapchunks=false: function worker(data,index,id) return f(data) end
- mapchunks=true: function worker(set,id) return set:map(f) end

data = {d1,d2,d3,..,dn}

.. mapchunks=false // default ..

local function worker(data1,index,id) 
  ... // data1=d1 d2 d3 ..

end

.. mapchunks=true // not default ..

local function worker(dataChunk,id) 
  // dataChunk = {d1,d2,..} {d5,d6,.. }

  for i=1,#dataChunk do
    local data1=dataChunk[i]
    ...
  end
end

apply(success,fail) wendet (sequenziell, Master Prozess) eine Funktion auf den gesamten Eingabedatenvektor (Ausgabe der vorherigen ode rletzten Berechnung) an. Trat bisher kein Fehler auf wird die Funktion success aufgerufen, ansonsten fail. Kann benutzt werden um z.B. die gesamten Daten auszugeben oder zu speichern.
reduce(fun,doparallel) wendet eine Reduktionsfunktion fun(a,b) : (a,b) → c auf den Datenvektor an und liefert einen reduzierten Vektor oder meistens einen Skalarwert. Standard ist sequenzielle Ausführung. Mit doparallel auf true gesetzt findet eine semi-parallele Verarbeitung statt (in Ebenen, siehe Abbildung unten).
eval(fun) wendet eine Funktion auf den gesamten Datensatz an.
done() wird zum Finalisierung einer MAR Verarbeitungskette aufgerufen und gibt belegte Ressourcen frei.

Aufgabe 1. Was sollte bei der Partitionierung beachtet werden (automatisch oder manuell durch den Nutzer)?

Datenart, nur spezielle Datentypen können mit MaR verarbeitet werden

Sortierung der Daten erforderlich

Gesamte Größe der Datenliste (es gibt eine Obergrenze)

Anzahl der Prozesse versa Gesamtgröße der Datenliste

Rechnerarchitektur (Anzah der physischen Prozessoren)

Balanzierung der Daten nach individueller Rechenzeit pro Datensatz damit die AUslastung bei 100% bleibt

Speichergröße des Rechners

Lösung.

Datenart, nur spezielle Datentypen können mit MaR verarbeitet werden

Sortierung der Daten erforderlich

Gesamte Größe der Datenliste (es gibt eine Obergrenze)

Anzahl der Prozesse versa Gesamtgröße der Datenliste

Rechnerarchitektur

Balanzierung der Daten nach individueller Rechenzeit pro Datensatz damit die AUslastung bei 100% bleibt

Speichergröße des Rechners

Prozessfluss

                     ┌────┐                            
                     │ P0 │ (map)                      
                     └──┬─┘                            
                       A│                              
        ┌───────┬───────┼───────┬───────┐              
  A= {a1│     a2│     a3│     a4│     a5│    ...}  ◀──┐
     ┌──┴─┐  ┌──┴─┐  ┌──┴─┐  ┌──┴─┐  ┌──┴─┐           │
     │ P1 │  │ P2 │  │ P3 │  │ P4 │  │ P5 │  ...      │
     └──┬─┘  └──┬─┘  └──┬─┘  └──┬─┘  └──┬─┘           │
  B= {b1│     b2│     b3│     b4│     b5│    ...} ────┘
        └───────┴───────┼───────┴───────┘              
                       B│                              
                     ┌──┴─┐                            
                     │ P0 │ (reduce)                   
                     └──┬─┘                            
                       c│                              
                        ▼                              
                      Result

Paralleles Map, sequenzielles Reduce

                     ┌────┐                              
                     │ P0 │ (map)                        
                     └──┬─┘                              
                       A│                                
        ┌───────┬───────┼───────┬───────┐                
  A= {a1│     a2│     a3│     a4│     a5│    ...}  ◀──┐  
     ┌──┴─┐  ┌──┴─┐  ┌──┴─┐  ┌──┴─┐  ┌──┴─┐           │  
     │ P1 │  │ P2 │  │ P3 │  │ P4 │  │ P5 │  ...      │  
     └──┬─┘  └──┬─┘  └──┬─┘  └──┬─┘  └──┬─┘           │  
  B= {b1│     b2│     b3│     b4│     b5│    ...} ────┘  
        └───────┴───────┼───────┴───────┘                
                       B│                                
        ┌───────────────┴────────────────────┐           
        │                                    │           
        ├────┐     ┌────┐     ┌────┐    ┌────┤           
        │ P1 │     │ P2 │     │ P3 │    │ P4 │           
        └──┬─┘     └─┬──┘     └──┬─┘    └─┬──┘           
           │         │           │        │              
           └────┬────┘           └───┬────┘              
                │                    │                   
             ┌──┴─┐                ┌─┴──┐                
             │ P1 │                │ P2 │   (reduce)     
             └──┬─┘                └─┬──┘                
                │                    │                   
                └──────────┬─────────┘                   
                           │                             
                        ┌──┴─┐                           
                        │ P1 │                           
                        ├────┘                           
                       c│                                
                        ▼                                
                      Result

Paralleles Map, semi-paralleles Reduce

A und B sind Vektoren oder Matrizen, und c ein reduzierter niderigdimensionalerer Wert.
Die Anzahl der Partitionen wird den Worker Prozessen angepasst.

Bei ungradzahliger Verteilung können die EIngabedatenpartitonen unterschiedlich groß sein.

Erzeugung einer Parallelen Pipeline:

Parallel=require 'parallel';
local options = {workers = 4, scheduler = "circular", verbose=0, remap=true, mapchunks=false}
local p = Parallel:new(data,options)

workers: Anzahl der Map (und maximale Anzahld er Reduce) Worker Prozesse;
scheduler: Aufteilungsalgorithmus für die Daten auf die Worker (sequential, circular, random);
remap: Wenn true (oder nicht definiert) dann wird die ursprüngliche Datenreihenfolge wiederhergestellt, ansonsten if false dann bleibt sie gemäß dem letzten Scheduling erhalten.

Anwendungen

A. Funktionale Rekursion versa Schleifeniteration

Ziel: Parallele Berechnung der Fibonacci Zahlen in einem Wertebereich von [*a*,*b*].
Eingabedaten: Eine Menge von Startwerten D₁={x}ⁱ
Ausgabedaten: Die abgebildete Menge von Fibonacci Zahlen D₂={fib(x)}ⁱ
Reduktion: Summe alle Element von D₂

Mittels Rekursion;
Mittels Schleifeniteration.

Parallele Berechnung (1)

Parallel=require 'parallel';
local nrun = 1 -- repeat workload
function sequence(a,b)
  local result = T{}
  for i=a,b do result:push(i) end
  return result
end
local function worker (data,index,id)
  return fib(data)
end

local data = sequence(30,42)
function sum (x,y) return x+y  end

local p = Parallel:new(data,{
 workers = 2,
 scheduler = 'circular'
})
print('Start ..')

p:time():
  map(worker):
  apply(function (r) print(r:print()) end):
  reduce(sum):
  apply(function (r) print(r:print()) end):
  time()
print('After MaR..')

▸

◼

✗

↻

≡

Aufgabe 2. Implementiere die Berechnung der Fibonacci Zahlen für ein gegebenes n jeweils als Rekursion (fib1) und als Schleifeniteration (fib2).

Lösung.

PGI+bG9jYWw8L2I+IDxiPmZ1bmN0aW9uPC9iPiBmaWIxKG4pIAogIDxiPmlmPC9iPiBuPjEgdGhlbiA8Yj5yZXR1cm48L2I+IGZpYjEobi0xKStmaWIxKG4tMikgPGI+ZWxzZTwvYj4gPGI+cmV0dXJuPC9iPiAxIDxiPmVuZDwvYj4KPGI+ZW5kPC9iPgo8Yj5sb2NhbDwvYj4gPGI+ZnVuY3Rpb248L2I+IGZpYjIobikgCiAgPGI+bG9jYWw8L2I+IGEsYixjPTEsMQogIGM9MQogIDxiPmZvcjwvYj4gaSA9IDIsbiA8Yj5kbzwvYj4KICAgIGM9YStiCiAgICBhPWIKICAgIGI9YwogIDxiPmVuZDwvYj4KICA8Yj5yZXR1cm48L2I+IGMKPGI+ZW5kPC9iPgo=

Frage 3. Welcher Speed-up wird für die Konfigurationen workers=1,2,3,4 erzielt? Vergleiche die Rekursions- und Schleifenmethode. Bei der Schleifenmethode muss nrun auf einen Wert > 1 gesetzt werden der pro Prozess wenigstens eine Laufzeit von 100ms erzielt. Probiere verschiedene Scheduler der Datenpartitionierung (circular, sequential, random), wo gibt es Unterschiede?

Lösung.

Rekursion: Vermutlich deutlich unter der Anzahl physischer Prozessoren. Grund könnte die Rekursion und Aktivität des Speichermanagements sein sowie Cache Effizienz (jeder Funktionsaufruf belegt anderen Speicherbereich).
Schleife: Vermutlich etwas kleiner als die Anzahl der physischen Prozessoren. Die Schleifeniteration ist im wesentlichen speicherkonstant (anders als Rekursion welche mindestens speicherlinear ist).

Frage 4. Wieso ist das Ergebnis enttäuschend? Wo lieht hier das Problem bei der Parallelisierung (bzgl. Beschleunigung)? Hinweis: Betrachte die Rechenkomplexität (in Abhängigkeit des Startwertes x)

Lösung.

S.o.
Aber noch ein weiterer Punkt: Die Verteilung der Eingabewerte bestimmt die gesamte Rechenzeit eines Prozesses. Die Rechenzeit ist hier abhängig von den Daten (größeres n heißt größere Rechenzeit).

Frage 5. Wie könnte eine gleichmäßige(re) Auslastung der Prozesse ohne a-priori Kenntnis der Berechnung erfolgen?

Lösung.

Bessere Verteilung bei der Partitionierung (random oder circular, niemals sequential)

B. Verschlüsselung

Im folgenden Beispiel soll eine Verschlüsselung parallel mit MaR durchgeführt werden die typisch gesicherten Anwednungen ist.
Es wird das Modul AES.lua benötigt (Datei muss sich im gleichen Verzeichnis wie weblvm befinden).
Eingabedaten: Eine Menge von Zeichenketten (Texten), randomisiert in worker1 erzeugt;
Ausgabedaten: Die verschlüsselten Zeichenketten
Reduktion durch einfaches Zusammenfügen

MaR in der Verschlüsselung

Parallel=require 'parallel';
local AES = require 'aes';

local STRLENGTH = 256
local key = 0x68C756C6C186436C9EC51C174C32AE81761389B5E5904E30BA57CCD911290ECC

function sequence(a,b)
  local result = T{}
  for i=a,b do result:push(i) end
  return result
end
local charset = {}

-- qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890
for i = 48,  57 do table.insert(charset, string.char(i)) end
for i = 65,  90 do table.insert(charset, string.char(i)) end
for i = 97, 122 do table.insert(charset, string.char(i)) end

local function strrnd(length)
  local s = ''
  -- TODO
  return s
end

-- Create random strings
local function worker1(data,index,id)
  -- Create random string
  local result
  -- TODO
  return result
end

-- Encrypt all strings
local function worker2(data,index,id)
  -- Create encrypted strings
  local result
  -- TODO
  return result
end

local data = sequence(1,1000)
local p = Parallel:new(data,{
 workers = 1
})
print('Start ..')
p:time():
  map(worker1):
  map(worker2):
  reduce(concatenate):
  time()
print('After MaR')

▸

◼

✗

↻

≡

Aufgabe 6. Implementiere die beiden Worker Funktionen. Worker 1 erzeugt einen String der Länge STRLENGTH mit randomisiert ausgewählten Zeichen aus der charset Tabelle. Dazu kann der charset[math.random(1, #charset)] Ausdruck verwendet werden. Zeichenketten werden mittels des .. Infixoperators verknüpft. Worker 2 soll nun die Verschlüsselung der Strings der jeweiligen Partition mittels AES durchführen. Dazu muss AES.ECB_256(AES.encrypt, key, str) ausgeführt werden. Schließlich sollen mittels der concatenate Funktion alle verschlüsselten Strings zu einem zusammengefügt werden (Funktion muss auch noch implementiert werden).

Lösung.

PGI+bG9jYWw8L2I+IDxiPmZ1bmN0aW9uPC9iPiBzdHJybmQobGVuZ3RoKQogIDxiPmxvY2FsPC9iPiBzPScnCiAgPGI+Zm9yPC9iPiBpPTEsbGVuZ3RoIDxiPmRvPC9iPgogICAgcyA9IHMgLi4gY2hhcnNldFttYXRoLnJhbmRvbSgxLCAjY2hhcnNldCldCiAgPGI+ZW5kPC9iPgogIDxiPnJldHVybjwvYj4gcwo8Yj5lbmQ8L2I+CgotLSBDcmVhdGUgcmFuZG9tIHN0cmluZ3MKPGI+bG9jYWw8L2I+IDxiPmZ1bmN0aW9uPC9iPiB3b3JrZXIxKGRhdGEsaW5kZXgsaWQpCiAgLS0gQ3JlYXRlIHJhbmRvbSBzdHJpbmcKICA8Yj5yZXR1cm48L2I+IHN0cnJuZChTVFJMRU5HVEgpOwo8Yj5lbmQ8L2I+CgotLSBFbmNyeXB0IGFsbCBzdHJpbmdzCjxiPmxvY2FsPC9iPiA8Yj5mdW5jdGlvbjwvYj4gd29ya2VyMihkYXRhLGluZGV4LGlkKQogIC0tIENyZWF0ZSBlbmNyeXB0ZWQgc3RyaW5ncwogIDxiPnJldHVybjwvYj4gQUVTLkVDQl8yNTYoQUVTLmVuY3J5cHQsIGtleSwgZGF0YSkKPGI+ZW5kPC9iPgo8Yj5sb2NhbDwvYj4gPGI+ZnVuY3Rpb248L2I+IGNvbmNhdGVuYXRlKHMxLHMyKQogIDxiPnJldHVybjwvYj4gczEuLnMyCjxiPmVuZDwvYj4K

Frage 7. Welcher Speed-up wird für workers=1,2,3,4 erzielt?

Frage 8. Wieso ist das Ergebnis hier besser (im Vergleich zu Beispiel 1)?

Lösung.

Gleichmäßiger work load für alle Prozesse (i.A. hier nicht abhängig von den Daten)

C. Bildverarbeitung und Matrixalgebra

Im folgenden Beispiel soll eine Matrixberechnung parallel mit MaR durchgeführt werden die typisch in der Bildverarbeitung ist
Eingabedaten: Matrizen (indirekt, shared environment), Matrizensegmente (direkt, Bounding Box)
Ausgabedaten: Mittelwert der Matrix

Hier werden nicht die eigentlichen Eingabedaten, die Matrix/die Matrizen, partitioniert, sondern eine Liste von Koordinaten kleiner Segmente der Matrix. Wichtig: Da die Matrizen von den Worker Prozessen geteilt werden, diese OO sind, aber bei der Serialisierung ihre "Methodentabelle" mit z.B. read und write verlieren, müssen diese im Worker Prozess noch einmal angehängt werden (siehe folgendes Beispiel). Die Segmentgrößen und Segmentanzahl sind unabhängig von den Anzahl der Prozesse!

MaR in der Matrixalgebra, hier am einfachen Beispiel der segmentierten Mittelwertberechnung einer Matrix m, mit w Spalten, h Zeilen und einer Segmentbreite/höhe von sw,sh.

require "Csp"
Parallel = require "parallel"

local w,h,sw,sh = 10,10,5,5
local m = Matrix:new({w,h},0)
for i=1,h do for j=1,w do m:write(math.random(1,1000),i,j) end end
-- bounding boxes
local data = {
  -- {x1,y1,x2,y2}
  {1,1,5,5},
  {6,1,10,5},
  {1,6,5,10},
  {6,6,10,10}
} 

options = {workers = 1, scheduler = "sequential", verbose=1}

p = Parallel:new(data,options)
local function init(id)
  require "Csp"
  -- Methoden wieder richtig als Metatabelle anhängen
  setmetatable(m, m.__class)
end
local function f(bbox,index,id) 
  local sum = 0
  for i=bbox[1],bbox[3] do
    for j = bbox[2],bbox[4] do
      sum = sum + m:read(j,i)
    end
  end
  return sum
end
local function sum (a,b) return a+b end

p:time():
  map(f,init):
  apply(function (r) print(r:print()) end):
  reduce(sum):  -- ergibt { totalsum }
  eval(function (r) return r[1]/(w*h) end): -- ergibt { mean }
  apply(function (r) print(r:print()) end):
  time():
  done()

▸

◼

✗

↻

≡

Aufgabe 9. Im obigen Beispiel ist die Segmenttabelle data für w=h=10 erstellt worden. Erstelle die Koordinatenboxen der Segmente mittels einer Schleifeniteration in Abhängigkeit von w,h, sw und sh, so dass die gesamte Matrix segmentiert wurde (keine Überlappung der Segmente!).

Lösung.

Frage 10. Welcher Speed-up wird für workers=1,2,3,4 erzielt? Gibt es Veränderungen in Abhängigkeit der Segmentgröße und dem Scheduleralgortihmus?

Aufgabe 11. jetzt geht es los. Es soll eine Matrixmultiplikation (Punktprodukt) zweier Matrizen a und b implementiert werden. Die Ergebnismatrix ist c. Auch hier vereinfachen wir das Problem indem geteilte Matrizen verwendet werden. Die zu partitionierenden Daten für die Pipeline sind hier wieder die Segmentkoordinaten.

Eine Matrixmultiplikation (Punktprodukt) verknüpft immer eine zeile von a mit einer Spalte von b; Multiplikation der Elemente und Summation aller Produkte (Produktsuemme).

\[ {c}_{{{i},{j}}}={\sum_{{{k}={1}}}^{{{n}}}}{a}_{{{i},{k}}}{b}_{{{k},{j}}} \]

Das heißt, der Eintrag c_i,j des Produkts wird erhalten, indem die Einträge der i-ten Zeile von A und der j-ten Spalte von B Term für Term multipliziert und diese n Produkte summiert werden. Mit anderen Worten, c_i,j ist das Skalarprodukt der i-ten Zeile von A und der j-ten Spalte von B.

MaR in der Matrixalgebra, hier am komplexren Beispiel der matrixmultiplikation, mit w Spalten, h Zeilen und einer Segmentbreite/höhe von sw,sh.

require "Csp"
Parallel = require "parallel"

local w,h,sw,sh = 10,10,5,5
local a,b,c = Matrix:new({w,h},0),Matrix:new({w,h},0),Matrix:new({w,h},0)
-- TODO initialisiere a und b
for i=1,h do for j=1,w do a:write(math.random(1,1000),i,j) end end
-- bounding boxes
-- TODO iterativ erzeugen
local data = {
  -- {x1,y1,x2,y2}
  {1,1,5,5},
  {6,1,10,5},
  {1,6,5,10},
  {6,6,10,10}
} 

options = {workers = 1, scheduler = "sequential", verbose=1}

p = Parallel:new(data,options)
local function init(id)
  require "Csp"
  -- Methoden wieder richtig als Metatabelle anhängen
  setmetatable(a, a.__class)
  setmetatable(b, b.__class)
  setmetatable(c, c.__class)
end
local function f(bbox,index,id) 
  local sum
  -- TODO
  -- Hier ist das Ergebnis in Matrix c!
  return 1
end

p:time():
  map(f,init):
  apply(function (r) print(r:print()) end):
  time():
  done()

▸

◼

✗

↻

≡

Frage 12. Welcher Speed-up wird für workers=1,2,3,4 erzielt? Gibt es Veränderungen in Abhängigkeit der Segmentgröße und dem Scheduleralgortihmus?

Hilfe

Einreichung (Assignment #2025-89346 )

Prüfen

Bewerten (Lehrer)

Created by the NoteBook Compiler Ver. 1.36.4 (c) Dr. Stefan Bosse (Sun Jun 08 2025 11:15:38 GMT+0200 (Central European Summer Time))