[JS]
[DE]
[PLUGIN] ../../build/popup.plugin
[PLUGIN] ../../build/lvm.plugin
[PLUGIN] ../../build/file.plugin
[PLUGIN] ../../build/image.plugin
[TITLE] Parallel LUA / CSP
[AUTHOR] Stefan Bosse
[VERSION] 7.2020
[FUN]
```
function jsexec (text,stdout,stderr) {
  var oldprint=print;
  print=stdout;
  try {
    stdout(eval(text)||'Ok.');
  } catch (e) {
    stderr(e.toString())
  }
  print=oldprint;
}
```

# Parallel Lua / Csp Tutorial (Teil 2)

## Vorbereitung

- 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 *MacOSX 32bit* 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](http://edu-9.de/Lehre/vpp2k)
  + 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 (ich arbeite daran dass das nicht eintritt und alle gestarten parallelen Prozesse == Threads abbrechbar sind)
  + **Ein Neustart des 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!
  
> Leider kann unter seltenen Bedingungen (Race conditions!) *lvm* fehlerhaft arbeiten und "abstürzen" → Auch ich als Autor von *lvm* habe mit den Tücken von parallelen und konkurrierenden Softwaresystemen zu kämpfen!

## Parallele Datenverarbeitung

In der folgenden Aufgabe soll die Parallelisierung einer Berechnung inklusive Synchronisation implementiert werden.

- Die Berechnung (eine Matrixoperation) wird dabei auf *N* parallele Prozesse verteilt
- Jeder Prozess verarbeitet dabeinen Teil der Eingabedaten (Matrix) und prodiziert einen Teil dewr Ausgabedaten

Synchronisation ist erforderlich bei:

1. Der Verteilung der Eingabedaten
2. Der Berechnung
3. Der Zusammenführung der Ausgabedaten

### Zeitmessung

- Die Performanz des parallelen Programms soll mit der rein sequenziellen (einprozess) Ausführung verglichen werden

- Dazu wird die Rechenzeit eines jeden Task mit der *luv.milli* Funktion gemessen:

[LVM] Zeitmessung (1)
```lua
require 'Csp';
local milli = function () return luv.milli()  end;
local t0=milli();
local function busy(n) 
  for i=1,n do end; -- busy loop
end
Seq({
  function () 
    local t0=milli()
    print('Task 1');
    busy(1E9);
    local t1=milli()
    print('Task 1: After busy .. '..(t1-t0)..'ms')
  end,
  function ()
    local t0=milli()
    print('Task 2');
    busy(1E9);
    local t1=milli()
    print('Task 2: After busy .. '..(t1-t0)..'ms')
  end
},{
  milli=milli,
  busy=busy
})
local t1=milli();
print('After Seq .. '..(t1-t0)..'ms')
```

- Und jetzt das gleiche als paralleles Prozesssystem:

[LVM] Zeitmessung (2)
```lua
require 'Csp';
local milli = function () return luv.milli()  end;
local t0=milli();
local function busy(n) 
  for i=1,n do end;  -- busy loop
end
Par({
  function () 
    local t0=milli()
    print('Task 1');
    busy(1E9);
    local t1=milli()
    print('Task 1: After busy .. '..(t1-t0)..'ms')
  end,
  function ()
    local t0=milli()
    print('Task 2');
    busy(1E9);
    local t1=milli()
    print('Task 2: After busy .. '..(t1-t0)..'ms')
  end
},{
  milli=milli,
  busy=busy
})
local t1=milli();
print('After Par .. '..(t1-t0)..'ms')
```
### Metriken

#### Beschleunigung

$
S(N) = \frac{t_{comp}(1)}{t_{comp}(N)}
$

#### Effizienz

$
E(N) = \frac{S(N)}{N}
$

[EXERCISE]
[QUESTION]
Berechne die Beschleunigung und Effizienz für obiges Beispiel

[INPUT]

[QUESTION]
Füge bei den sequenziellen und parallelen Prozesskonstruktor zwei weitere Prozesse hinzu. Wie verhält sich *S* und *E*?

[INPUT]

[QUESTION]
Betrachte die Rechnerarchitektur von modernen Computern (Mehrkernprozessor, Speicherhierarchie). Wo könnten die Gründe für das (schlechte?) Abschneiden des 4-Prozess Systems liegen?

[INPUT]

[EXERCISE]

## Geteilte Daten

- Datencontainer in Form von Matrizen können durch verschiedene Prozesse geteilt werden (Shared Memory)

- Es können ein-, zwei- und dreidimensionale "Matrizen" erzeugt werden

- Es stehen drei Datentypen zur Verfügung: *int*, *float*, *double*

```lua
Matrix:new(dims,init?,datatype?) -> 'datatype matrix
Matrix.int(dims,init?) -> int matrix
Matrix.float(dims,init?) -> float matrix
Matrix.double(dims,init?) -> double matrix
matrix:print() -> string
matrix:setall(v)
matrix:read(i,j?,k?) -> 'a
matrix:write(val,i,j?,k?)
```

[LVM] Benutzung von geteilten Matrizen
```lua
require 'Csp';
Par({
  function ()
    sleep(100)
    print('Task 1 got: '..mat:read(1,1))
  end,
  function ()
    print('Task 2 got: '..mat:read(1,1))
    mat:write(3.14,1,1)
  end
},{
  mat=Matrix.float({64,64}):random()
})
```

## Bildverarbeitung

[IMAGE] Load and Show Test Image { eval:jsexec }
```js
image = {}
File.load('test2.png','image/png',function (data) {
  image.name='test2.png';
  print(data.length+' bytes');
  image.data=PNG.decode(data);
  image.input=PNG.toGrayArray(image.data);
  print(image.data.width,image.data.height)
  show(image.input,{scale:2});
});
```

### Speicherung der Eingabedaten

- Die Bilddatei muss in dem gleichen Verzeichnis abgelegt werden wo auch *lvm* mit der WEB Shell läuft.

[CODE]
```js
Save(image.input,'input.json')
```

### Verarbeitung in Lua

[LVM] Bilddaten in Lua verarbeiten
```lua
-- HEADER --
require 'Csp';
json=require 'json'

local function read_file(path)
  local file = io.open(path, "rb") -- r read mode and b binary mode
  if not file then return nil end
  local content = file:read "*a" -- *a or *all reads the whole file
  file:close()
  return content
end
local function write_file(path,data)
  file = io.open(path, "w")
  file:write(data)
  file:close()
end

print ('Reading file input.json..')
local fileContent = read_file("input.json")
print ('Decoding file input.json..')
local input = json.decode(fileContent);
print ('Creating Matrix ..')
local data1 = Matrix:new({#input,#input[1]}, function (i,j) 
  return input[i][j]
end);
local data2 = Matrix:new({#input,#input[1]},0);
-- HEADER --

print('Test pixel:', input[2][3], data1:read(2,3))

-- Daten transformieren
print ('Computing ..')
local t0=luv.milli()
Seq({
  function () 
    for i=1,inp.rows do
      for j=1,inp.cols do
        out:write(255-inp:read(i,j),i,j);
      end
    end
  end
},{
  inp=data1,
  out=data2,
})
local t1=luv.milli()
print(t1-t0)

print ('Encoding output data ..')
local output = json.encode(data2:toArray());
print ('Writing output file output.json..')
write_file('output.json',output);
print ('Done.')
```

### Laden von Ergebnissen

[CODE]
```js
Load(function (data) { image.output=data; print('Done.') })
```

[IMAGE] Show Output Image { eval:jsexec }
```js
show(image.output,{scale:2});
```

## Parallelisierung

### Bildinvertierung

[EXERCISE]

Nehme das vorherige Template für das Einlesen und Ausgeben der Bilddaten (Die Datei *input.json*  muss bereits existieren). Siehe unten. Immer das Ergebnisbild einlesen und testen (ansehen)!

[QUESTION]
Implementiere den seq. Prozess für die Bildinvertierung als parallelen Prozess mit Verteilungs- und Kollektionssynchronisation (Semaphore oder Barriere) für N=2,3,4. Welche Beschleunigung und Effizienz ergibt sich? Die Eingabedaten sollen dabei segmentiert und in den verschiedenen Prozessen partioniert werden.

[INPUT]

[QUESTION]
Ändert sich etwas an *S* und *E* wenn man statt spaltenweise die Matrizen zeilenweise durchläuft? Wenn ja, woran könnte es liegen?

[INPUT]

[EXERCISE]

[LVM] Parallele Bilddatenverarbeitung (Invertierung)
```lua
-- HEADER --
require 'Csp';
json=require 'json'

print('Test pixel:', input[2][3], data1:read(2,3))

-- AUFGABE Start !!!! --
-- HIER die parallele Variante ---
Par({

},{
  inp=data1,
  out=data2,
})
-- AUFGABE ENDE ---

local t2=luv.milli()
print('Par',t2-t1)

print ('Encoding output data ..')
local output = json.encode(data2:toArray());
print ('Writing output file output.json..')
write_file('output.json',output);
print ('Done.')
```

### Laden von Ergebnissen

- Die Ergebnisdatei (bei erfolgreicher Ausführung des Lua Programms) ist *output.json*

[CODE]
```js
if (typeof image =='undefined') image={}
Load(function (data) { image.output=data; print('Done.') })
```

[IMAGE] Show Output Image { eval:jsexec }
```js
show(image.output,{scale:2});
```

## Bildglättung

### Erzeugung eines verrauschten Bildes

- Das Originalbild muss geladen sein (siehe oben)!

[IMAGE] Create and Show Noisy Image { eval:jsexec }
```js
var noiseK = 0.2;
image.noise = image.input.map (function (row) {
    return row.map(function(v) {
      return Math.floor(Math.random()*v);
    })
  });
show(image.noise,{scale:2})
```

### Speicherung der Eingabedaten

- Die Bilddatei muss in dem gleichen Verzeichnis abgelegt werden wo auch *lvm* mit der WEB Shell läuft.

[CODE]
```js
Save(image.noise,'inputNoise.json')
```

[EXERCISE]

Nehme das vorherige Template für das Einlesen und Ausgeben der Bilddaten (Die Datei *inputNoise.json*  muss bereits existieren). Siehe unten. Immer das Ergebnisbild einlesen und testen (ansehen)! Es wird die Bildglättung aus Tutorial5 verwendet (naiver Algorithmus, Moore Nachbarschaft).

[QUESTION]
Implementiere den seq. Prozess für die Bildglättung als parallelen Prozess mit Verteilungs- und Kollektionssynchronisation (Semaphore oder Barriere) für N=2,3,4. Welche Beschleunigung und Effizienz ergibt sich? Die Eingabedaten sollen dabei segmentiert und in den verschiedenen Prozessen partioniert werden.

[INPUT]

[QUESTION]
Ändert sich etwas an *S* und *E* wenn man statt spaltenweise die Matrizen zeilenweise durchläuft? Wenn ja, woran könnte es liegen?

[INPUT]

[EXERCISE]

[LVM] Parallele Bilddatenverarbeitung (Invertierung)
```lua
-- HEADER --
require 'Csp';
json=require 'json'

print ('Reading file inputNoise.json..')
local fileContent = read_file("inputNoise.json")
print ('Decoding file inputNoise.json..')
local input = json.decode(fileContent);
print ('Creating Matrix ..')
local data1 = Matrix:new({#input,#input[1]}, function (i,j) 
  return input[i][j]
end);
local data2 = Matrix:new({#input,#input[1]},0);
-- HEADER --

print('Test pixel:', input[2][3], data1:read(2,3))

-- Daten transformieren
print ('Computing ..')
local t0=luv.milli()
Seq({
  function () 
    for i=2,inp.rows-1 do
      for j=2,inp.cols-1 do
        local v=0;
        for n=-1,1 do
          for m=-1,1 do
            v=v+inp:read(i+n,j+m);
          end
        end
        v=v/9;
        out:write(v,i,j);
      end
    end
  end
},{
  inp=data1,
  out=data2,
})
local t1=luv.milli()
print('Seq', t1-t0)

-- AUFGABE Start !!!! --
-- HIER die parallele Variante ---
Par({
  function () end
},{
  inp=data1,
  out=data2,
})
-- AUFGABE ENDE ---

local t2=luv.milli()
print('Par',t2-t1)

print ('Encoding output data ..')
local output = json.encode(data2:toArray());
print ('Writing output file outputNoise.json..')
write_file('outputNoise.json',output);
print ('Done.')
```

### Laden von Ergebnissen

- Die Ergebnisdatei (bei erfolgreicher Ausführung des Lua Programms) ist *outputNoise.json*

[CODE]
```js
if (typeof image =='undefined') image={}
Load(function (data) { image.outputNoise=data; print('Done.') })
```

[IMAGE] Show Output Image { eval:jsexec }
```js
show(image.outputNoise,{scale:2});
```

Parallel Lua / Csp Tutorial (Teil 2)

Vorbereitung

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 MacOSX 32bit 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 (ich arbeite daran dass das nicht eintritt und alle gestarten parallelen Prozesse == Threads abbrechbar sind)
- Ein Neustart des 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!

Leider kann unter seltenen Bedingungen (Race conditions!) lvm fehlerhaft arbeiten und "abstürzen" → Auch ich als Autor von lvm habe mit den Tücken von parallelen und konkurrierenden Softwaresystemen zu kämpfen!

Parallele Datenverarbeitung

In der folgenden Aufgabe soll die Parallelisierung einer Berechnung inklusive Synchronisation implementiert werden.

Die Berechnung (eine Matrixoperation) wird dabei auf N parallele Prozesse verteilt
Jeder Prozess verarbeitet dabeinen Teil der Eingabedaten (Matrix) und prodiziert einen Teil dewr Ausgabedaten

Synchronisation ist erforderlich bei:

Der Verteilung der Eingabedaten
Der Berechnung
Der Zusammenführung der Ausgabedaten

Zeitmessung

Die Performanz des parallelen Programms soll mit der rein sequenziellen (einprozess) Ausführung verglichen werden
Dazu wird die Rechenzeit eines jeden Task mit der luv.milli Funktion gemessen:

Zeitmessung (1)

require 'Csp';
local milli = function () return luv.milli()  end;
local t0=milli();
local function busy(n) 
  for i=1,n do end; -- busy loop
end
Seq({
  function () 
    local t0=milli()
    print('Task 1');
    busy(1E9);
    local t1=milli()
    print('Task 1: After busy .. '..(t1-t0)..'ms')
  end,
  function ()
    local t0=milli()
    print('Task 2');
    busy(1E9);
    local t1=milli()
    print('Task 2: After busy .. '..(t1-t0)..'ms')
  end
},{
  milli=milli,
  busy=busy
})
local t1=milli();
print('After Seq .. '..(t1-t0)..'ms')

▸

◼

✗

↻

Und jetzt das gleiche als paralleles Prozesssystem:

Zeitmessung (2)

require 'Csp';
local milli = function () return luv.milli()  end;
local t0=milli();
local function busy(n) 
  for i=1,n do end;  -- busy loop
end
Par({
  function () 
    local t0=milli()
    print('Task 1');
    busy(1E9);
    local t1=milli()
    print('Task 1: After busy .. '..(t1-t0)..'ms')
  end,
  function ()
    local t0=milli()
    print('Task 2');
    busy(1E9);
    local t1=milli()
    print('Task 2: After busy .. '..(t1-t0)..'ms')
  end
},{
  milli=milli,
  busy=busy
})
local t1=milli();
print('After Par .. '..(t1-t0)..'ms')

▸

◼

✗

↻

Metriken

Beschleunigung

\[ S(N) = \frac{t_{comp}(1)}{t_{comp}(N)} \]

Effizienz

\[ E(N) = \frac{S(N)}{N} \]

Aufgabe.

Frage. Berechne die Beschleunigung und Effizienz für obiges Beispiel

Frage. Füge bei den sequenziellen und parallelen Prozesskonstruktor zwei weitere Prozesse hinzu. Wie verhält sich S und E?

Frage. Betrachte die Rechnerarchitektur von modernen Computern (Mehrkernprozessor, Speicherhierarchie). Wo könnten die Gründe für das (schlechte?) Abschneiden des 4-Prozess Systems liegen?

Geteilte Daten

Datencontainer in Form von Matrizen können durch verschiedene Prozesse geteilt werden (Shared Memory)
Es können ein-, zwei- und dreidimensionale "Matrizen" erzeugt werden
Es stehen drei Datentypen zur Verfügung: int, float, double

Matrix:new(dims,init?,datatype?) -> 'datatype matrix
Matrix.int(dims,init?) -> int matrix
Matrix.float(dims,init?) -> float matrix
Matrix.double(dims,init?) -> double matrix
matrix:print() -> string
matrix:setall(v)
matrix:read(i,j?,k?) -> 'a
matrix:write(val,i,j?,k?)

Benutzung von geteilten Matrizen

require 'Csp';
Par({
  function ()
    sleep(100)
    print('Task 1 got: '..mat:read(1,1))
  end,
  function ()
    print('Task 2 got: '..mat:read(1,1))
    mat:write(3.14,1,1)
  end
},{
  mat=Matrix.float({64,64}):random()
})

▸

◼

✗

↻

Bildverarbeitung

Load and Show Test Image

image = {}
File.load('test2.png','image/png',function (data) {
  image.name='test2.png';
  print(data.length+' bytes');
  image.data=PNG.decode(data);
  image.input=PNG.toGrayArray(image.data);
  print(image.data.width,image.data.height)
  show(image.input,{scale:2});
});

▸

✗

Speicherung der Eingabedaten

Die Bilddatei muss in dem gleichen Verzeichnis abgelegt werden wo auch lvm mit der WEB Shell läuft.

Save(image.input,'input.json')

▸

✗

Verarbeitung in Lua

Bilddaten in Lua verarbeiten

-- HEADER --
require 'Csp';
json=require 'json'

local function read_file(path)
  local file = io.open(path, "rb") -- r read mode and b binary mode
  if not file then return nil end
  local content = file:read "*a" -- *a or *all reads the whole file
  file:close()
  return content
end
local function write_file(path,data)
  file = io.open(path, "w")
  file:write(data)
  file:close()
end

print ('Reading file input.json..')
local fileContent = read_file("input.json")
print ('Decoding file input.json..')
local input = json.decode(fileContent);
print ('Creating Matrix ..')
local data1 = Matrix:new({#input,#input[1]}, function (i,j) 
  return input[i][j]
end);
local data2 = Matrix:new({#input,#input[1]},0);
-- HEADER --

print('Test pixel:', input[2][3], data1:read(2,3))

-- Daten transformieren
print ('Computing ..')
local t0=luv.milli()
Seq({
  function () 
    for i=1,inp.rows do
      for j=1,inp.cols do
        out:write(255-inp:read(i,j),i,j);
      end
    end
  end
},{
  inp=data1,
  out=data2,
})
local t1=luv.milli()
print(t1-t0)

print ('Encoding output data ..')
local output = json.encode(data2:toArray());
print ('Writing output file output.json..')
write_file('output.json',output);
print ('Done.')

▸

◼

✗

↻

Laden von Ergebnissen

Load(function (data) { image.output=data; print('Done.') })

▸

✗

Show Output Image

show(image.output,{scale:2});

▸

✗

Parallelisierung

Bildinvertierung

Aufgabe.

Nehme das vorherige Template für das Einlesen und Ausgeben der Bilddaten (Die Datei input.json muss bereits existieren). Siehe unten. Immer das Ergebnisbild einlesen und testen (ansehen)!

Frage. Implementiere den seq. Prozess für die Bildinvertierung als parallelen Prozess mit Verteilungs- und Kollektionssynchronisation (Semaphore oder Barriere) für N=2,3,4. Welche Beschleunigung und Effizienz ergibt sich? Die Eingabedaten sollen dabei segmentiert und in den verschiedenen Prozessen partioniert werden.

Frage. Ändert sich etwas an S und E wenn man statt spaltenweise die Matrizen zeilenweise durchläuft? Wenn ja, woran könnte es liegen?

Parallele Bilddatenverarbeitung (Invertierung)

-- HEADER --
require 'Csp';
json=require 'json'

local function read_file(path)
  local file = io.open(path, "rb") -- r read mode and b binary mode
  if not file then return nil end
  local content = file:read "*a" -- *a or *all reads the whole file
  file:close()
  return content
end
local function write_file(path,data)
  file = io.open(path, "w")
  file:write(data)
  file:close()
end

print ('Reading file input.json..')
local fileContent = read_file("input.json")
print ('Decoding file input.json..')
local input = json.decode(fileContent);
print ('Creating Matrix ..')
local data1 = Matrix:new({#input,#input[1]}, function (i,j) 
  return input[i][j]
end);
local data2 = Matrix:new({#input,#input[1]},0);
-- HEADER --

print('Test pixel:', input[2][3], data1:read(2,3))

-- Daten transformieren
print ('Computing ..')
local t0=luv.milli()
Seq({
  function () 
    for i=1,inp.rows do
      for j=1,inp.cols do
        out:write(255-inp:read(i,j),i,j);
      end
    end
  end
},{
  inp=data1,
  out=data2,
})
local t1=luv.milli()
print('Seq', t1-t0)


-- AUFGABE Start !!!! --
-- HIER die parallele Variante ---
Par({

},{
  inp=data1,
  out=data2,
})
-- AUFGABE ENDE ---

local t2=luv.milli()
print('Par',t2-t1)


print ('Encoding output data ..')
local output = json.encode(data2:toArray());
print ('Writing output file output.json..')
write_file('output.json',output);
print ('Done.')

▸

◼

✗

↻

Laden von Ergebnissen

Die Ergebnisdatei (bei erfolgreicher Ausführung des Lua Programms) ist output.json

if (typeof image =='undefined') image={}
Load(function (data) { image.output=data; print('Done.') })

▸

✗

Show Output Image

show(image.output,{scale:2});

▸

✗

Bildglättung

Erzeugung eines verrauschten Bildes

Das Originalbild muss geladen sein (siehe oben)!

Create and Show Noisy Image

var noiseK = 0.2;
image.noise = image.input.map (function (row) {
    return row.map(function(v) {
      return Math.floor(Math.random()*v);
    })
  });
show(image.noise,{scale:2})

▸

✗

Speicherung der Eingabedaten

Die Bilddatei muss in dem gleichen Verzeichnis abgelegt werden wo auch lvm mit der WEB Shell läuft.

Save(image.noise,'inputNoise.json')

▸

✗

Aufgabe.

Nehme das vorherige Template für das Einlesen und Ausgeben der Bilddaten (Die Datei inputNoise.json muss bereits existieren). Siehe unten. Immer das Ergebnisbild einlesen und testen (ansehen)! Es wird die Bildglättung aus Tutorial5 verwendet (naiver Algorithmus, Moore Nachbarschaft).

Frage. Implementiere den seq. Prozess für die Bildglättung als parallelen Prozess mit Verteilungs- und Kollektionssynchronisation (Semaphore oder Barriere) für N=2,3,4. Welche Beschleunigung und Effizienz ergibt sich? Die Eingabedaten sollen dabei segmentiert und in den verschiedenen Prozessen partioniert werden.

Frage. Ändert sich etwas an S und E wenn man statt spaltenweise die Matrizen zeilenweise durchläuft? Wenn ja, woran könnte es liegen?

Parallele Bilddatenverarbeitung (Invertierung)

-- HEADER --
require 'Csp';
json=require 'json'

local function read_file(path)
  local file = io.open(path, "rb") -- r read mode and b binary mode
  if not file then return nil end
  local content = file:read "*a" -- *a or *all reads the whole file
  file:close()
  return content
end
local function write_file(path,data)
  file = io.open(path, "w")
  file:write(data)
  file:close()
end

print ('Reading file inputNoise.json..')
local fileContent = read_file("inputNoise.json")
print ('Decoding file inputNoise.json..')
local input = json.decode(fileContent);
print ('Creating Matrix ..')
local data1 = Matrix:new({#input,#input[1]}, function (i,j) 
  return input[i][j]
end);
local data2 = Matrix:new({#input,#input[1]},0);
-- HEADER --

print('Test pixel:', input[2][3], data1:read(2,3))

-- Daten transformieren
print ('Computing ..')
local t0=luv.milli()
Seq({
  function () 
    for i=2,inp.rows-1 do
      for j=2,inp.cols-1 do
        local v=0;
        for n=-1,1 do
          for m=-1,1 do
            v=v+inp:read(i+n,j+m);
          end
        end
        v=v/9;
        out:write(v,i,j);
      end
    end
  end
},{
  inp=data1,
  out=data2,
})
local t1=luv.milli()
print('Seq', t1-t0)


-- AUFGABE Start !!!! --
-- HIER die parallele Variante ---
Par({
  function () end
},{
  inp=data1,
  out=data2,
})
-- AUFGABE ENDE ---

local t2=luv.milli()
print('Par',t2-t1)


print ('Encoding output data ..')
local output = json.encode(data2:toArray());
print ('Writing output file outputNoise.json..')
write_file('outputNoise.json',output);
print ('Done.')

▸

◼

✗

↻

Laden von Ergebnissen

Die Ergebnisdatei (bei erfolgreicher Ausführung des Lua Programms) ist outputNoise.json

if (typeof image =='undefined') image={}
Load(function (data) { image.outputNoise=data; print('Done.') })

▸

✗

Show Output Image

show(image.outputNoise,{scale:2});

▸

✗

Created by the NoteBook Compiler Ver. 1.3.9 (c) Dr. Stefan Bosse (Fri Jul 31 2020 09:29:49 GMT+0200 (CET))