[JS]
[DE]
[PLUGIN] popup.plugin
[PLUGIN] lvm.plugin
[PLUGIN] file.plugin
[PLUGIN] button.plugin
[PLUGIN] help.plugin

[TITLE] Parallel Lua / CSP Tutorial - Nachrichtenbasierte Kommunizierende Prozesse
[AUTHOR] Stefan Bosse
[VERSION] 6.2024

# Übung 7 - Parallel Lua / CSP Tutorial - Nachrichtenbasierte Kommunizierende Prozesse

[FUN]
```js
Plot.create=function (data,options) { console.log(options); drawPlot(0,Plot(data,options))}
new HelpUI({
  welcome:'Enter search pattern (with optional wildcards *)',
  label:'HelpBot',
  callback:function (text) {
    return 'Sorry, found nothing helpful.'
  }
})
```

[TOC]

## Vorbereitung und Verwendung

>! Minimalanforderungen: lvm 1.1.15

- Es wird die parallele LuaJit VM *lvm* mit integrierten CSP Modul 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. Unter Microsoft Windows kann es zu funktionalen Abweichungen und Einschränkungen von *lvm* kommen → [lvm](http://edu-9.de/Lehre/vpp3k), die aber für die Übung nicht relevant sind.
  + 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
```

- Es wird mindestens *lvm* version 1.1.14 benötigt!

+ 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!
  
1. Der Programmcode kann in dem oberen Teilfenster eines Snippets verändert werden.
2. Der Programmcode wird ausgeführt durch Drücken der Playtaste ▸ im unteren Teilfenster (Ausgabekonsole).
3. Die Ausgabekonsole kann auf der rechten Seite gelöscht werden durch Drücken von ✗.
4. Hin und wieder kann eine Aktualisierung des Ausgabefensters durch Drücken des Knopfes ↻ erforderlich sein.
5. Bei parallelen Prozessen werden jeweils neue VM Instanzen in Threads gestartet. Wenn etwas schief läuft kann das Programm hängen und nicht terminieren (also der aktuelle Codeabschnitt). Der Abbruch kann versucht werden durch Drücken des Knopfes ◼.

[LVM] Ein Beispiel
```lua
function foo(x)
  return x+math.random()
end
print(foo(2))
```

## Channel

Der Kommuniaktionskanal wurde bereits eingeführt. Hier noch einmal die Zusammenfassung:

- Ein Channel ist entweder ein FIFO Speicher (Puffer/Queue, *N* Zellen) oder ein Redezvouz Kontakt (*N*=0)
- Es gibt zwei Operatione
  + Lesen (Read)
  + Schreiben (Write)
- Als Queue gibt es zwei Synchronisationsereignisse die zur Blockierung des aufrufenden Prozesses führen kann:
  + Keine Daten im Puffer (Empty) ⇒ Read Sync
  + Kein freier Platz m Puffer für neue Daten (Full) ⇒ Write Sync

[LVM] Ein Beispiel: Verwendung eines Chennels in Par Prozessen
```lua
require "Csp"
local ch = Channel(1)
Par({
  function ()
    local x = ch:read()
    print("Consumed "..x)
  end,
  function ()
    local x = "Data"
    print("Producing "..x)
    ch:write(x)
  end
},{
  ch=ch
})
```

>! Mit Kanälen können höhere und komplexere Kommunikationsprotokolle für die Prozesskommunikation eingesetzt werden.

## Der Alt Prozesskonstruktor

>! Der Alt Prozesskonstruktor implemtiert einen mutualen Ausschluss auf möglicherweise parallelen Ereignissen, und führt eine Auswahl und Sequenzialisierung ein. So kann mit einem Alt Prozesse parallel auf das Eintreten von Ereignissen gewartet werden, prominent das Warten auf Daten in mehreren Kanälen.

- Ein Alt Prozesskonstruktor muss immer in einen Par Prozess eingebettet werden (oder Fork oder Co), ansonsten entsteht eine permanente Blockierung des aufrufenden Prozesses (Deadlock!)
- Ein Alt Prozesse besteht aus Teilprozessen mit konditionalen Vor- und Nachprozessen
- Kompakte Version: Der Vorprozess ist immer die erste Anweisung, der Nachprozess alle folgenden Anweisungen.
- Derzeit wird nur das Lesen aus einem Channel als konditionaler Vorprozess unterstützt.

[LVM] Ein Beispiel: Verwendung eines Alt Prozesses in Par Prozessen { lines:10 }
```lua
print('Before Alt...')
require "Csp"
local ch1 = Channel(1)
local ch2 = Channel(1)
local ch3 = Channel(1)
Par({
  function ()
    print('Alt..')
    Alt({
      function ()
        local x = ch1:read()
        print(x)
      end,
      function ()
        local x = ch2:read()
        print(x)  
      end,
      function ()
        local x = ch3:read()
        print(x)  
      end  
    })
  end,
  function (id)
    print('Master ..')
    ch1:write('A')
  end
},{
  ch1=ch1,
  ch2=ch2,
  ch3=ch3
})
print('After Alt...')
```

[TODO]
Welcher Wert wird ausgegeben? Was passiert wenn vor dem Alt Operator ein Wert in den Channel 2 geschrieben wird (also `ch2:write("B")`)?

[INPUT]

## Kommunizierende Prozesse

In dieser Aufgabe sollen mehrere Prozesse mit einem Verwaltungsprozess kommunizieren. Der Verwaltungsprozess verwaltet und verteilte geteilte Ressourcen ohne Deadlock Gefahr.
Ein Beispiel ist nachfolgend die Implementierung eines Semaphor durch einen Prozess. Die anderen Prozesse fragen die Ressource über Kommunikationskanäle an, und bekommen die Antwort über einen Kommunikationskanal. Es gibt zwei Kanäle pro Prozess und Ressource:

1. Anfrage (Request)
2. Antwort (Reply)

![#semchann width=80%](images/semachann.png)

[LVM] Mit Nachrichten kommunizierende Prozesse und zentraler Verwaltung einer Lock Ressource. { lines:10 }
```lua
require "Csp"

local chReq = {
  Channel (1),
  Channel (1)
}
local chRep = {
  Channel (1),
  Channel (1)
}
local function lock(chReq,chRep)
  chReq:write({
    cmd = "LOCK",
    timestamp = luv.milli()
  })
  local rep = chRep:read()
  return rep
end
local function unlock(chReq,chRep)
  chReq:write({
    cmd = "UNLOCK",
    timestamp = luv.milli()
  })
  local rep = chRep:read()
  return rep
end

Par({
  function (id) 
    -- setmetatable(chreq, chreq.__class)
    -- setmetatable(chrep, chrep.__class)
    local rep = lock(chReq[id],chRep[id])
    print(rep)
    local rep = unlock(chReq[id],chRep[id])
    print(rep)
    print('End',id)
  end,
  function (id) 
    -- setmetatable(chreq, chreq.__class)
    -- setmetatable(chrep, chrep.__class)
    local rep = lock(chReq[id],chRep[id])
    print(rep)
    local rep = unlock(chReq[id],chRep[id])
    print(rep)
    print('End',id)
  end,
  function (id)
    local eos = false
    local locked = false
    local waiters = T{}
    while not eos do
      local req
      Alt({
        function (id)
          req = chReq[id]:read()
          req.index=id
        end,
        function (id)
          req = chReq[id]:read()
          req.index=id
        end        
      })
      print('Master',req.cmd,req.index)
      if (req.cmd=="LOCK") then
        if locked then
          waiters:push(req.index)
        else
          locked=true
          chRep[req.index]:write({
            cmd       = "ACK",
            timestamp = luv.milli(),
            state     = locked
          })
        end
      end
      if (req.cmd=="UNLOCK") then
        if locked then
          if #waiters>0 then
            local next = waiters:pop()
            chRep[next]:write({
              cmd       = "ACK",
              timestamp = luv.milli(),
              state     = locked
            })
            chRep[req.index]:write({
              cmd       = "ACK",
             timestamp = luv.milli(),
             state     = locked
            })
          else
            locked=false
            chRep[req.index]:write({
              cmd       = "ACK",
             timestamp = luv.milli(),
             state     = locked
            })
          end
        else
          chRep[req.index]:write({
            cmd       = "ERROR",
            timestamp = luv.milli(),
            error     = "ENOTLOCKED",
            state     = locked
          })
        end
      end      
    end
  end
},{
  chReq=chReq,
  chRep=chRep,
  lock = lock,
  unlock = unlock
})
```

>@ Die auskommentierten Zeilen `setmetatable(chreq, chreq.__class)` müssen bei *lvm* version < 1.15 aktiviert werden.

[TODO]
Implementiere anstelle eines Locks ein Semaphor Objekt. Teste die Ausführung mit drei Prozessen.

[INPUT]

## Kommunizierende Dinierende Philosophen

[TODO]
Implementiere die Dinierenden Philosophen mit einem zentralen Verwaltungsprozess der die *N* Gabeln verwaltet. Die Anfrage von Gabeln erfolgt über Kommunikationskanäle. Der Alt Prozesskonstruktor muss vom Verwaltungsprozess verwendet werden um auf allen Anfragekanälen Nachrichten empfangen zu können.

[LVM] Implementierung der Dinierenden Philosophen ohne Deadlock mittels Alt, Par, und Kommunikationskanälen für Anfrage und Bestätigung von Ressourcen (hier die Gabeln) { lines:10 }
```lua
local ch_p1_req = Channel(1)
local ch_p1_rep = Channel(1)
Par({
  function () 
    -- Philo 1
  end,
  function () 
    -- Philo 2
  end,
  -- ....
  function ()
    -- Verwaltung
    Alt({
    
    })
  end
},{

})
```

[QUESTION]
Wie müssen die Gabeln angefragt werden damit kein Deadlock auftreten kann? Können die Gabeln sequenziell nacheinander angefragt werden? Wo wird Atomarität verletzt (siehe auch Test & Set Probleme).

[INPUT]

---

[BUTTON] Hilfe { action:post; label:Absenden; style:"color:red" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['Name','Email','Pin','Frage'],
  email:{from:'$Email', to:'sbosse@uni-bremen.de', name:'$Name'},
  subject:'Hilfe Kurs ML $TITLE',
  message:'$Name: $Frage',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:1827,
}
```

[BUTTON] Einreichung (Assignment #2024-90707 ) { action:post; label:Absenden; style:"color:green" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['Name','Email','Pin','Kommentar'],
  submit: { from:'$Email', to:'sbosse@uni-bremen.de' },
  assignment:'2024-90707',
  name : '$Name',
  comment : '$Kommentar',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:1827,
}
```

[BUTTON] Prüfen { action:post; label:Laden; style:"color:browm" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['ID','Pin'],
  load: { id:'$ID' },
  pin:[1827,9223],
}
```

[BUTTON] Bewerten (Lehrer) { action:post; label:Absenden; style:"color:blue" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['ID','Marking','Pin','Remarks'],
  submit: { id:'$ID', from:'sbosse@uni-bremen.de', name:'$Name' },
  marks : '$Marking',
  remarks : '$Remarks',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:9223,
}
```

---

Übung 7 - Parallel Lua / CSP Tutorial - Nachrichtenbasierte Kommunizierende Prozesse

Inhalt.

Übung 7 - Parallel Lua / CSP Tutorial - Nachrichtenbasierte Kommunizierende Prozesse

Vorbereitung und Verwendung

Channel

Der Alt Prozesskonstruktor

Kommunizierende Prozesse

Kommunizierende Dinierende Philosophen

Vorbereitung und Verwendung

Minimalanforderungen: lvm 1.1.15

Es wird die parallele LuaJit VM lvm mit integrierten CSP Modul 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. Unter Microsoft Windows kann es zu funktionalen Abweichungen und Einschränkungen von lvm kommen → lvm, die aber für die Übung nicht relevant sind.
- 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

Es wird mindestens lvm version 1.1.14 benötigt!

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!

Der Programmcode kann in dem oberen Teilfenster eines Snippets verändert werden.
Der Programmcode wird ausgeführt durch Drücken der Playtaste ▸ im unteren Teilfenster (Ausgabekonsole).
Die Ausgabekonsole kann auf der rechten Seite gelöscht werden durch Drücken von ✗.
Hin und wieder kann eine Aktualisierung des Ausgabefensters durch Drücken des Knopfes ↻ erforderlich sein.
Bei parallelen Prozessen werden jeweils neue VM Instanzen in Threads gestartet. Wenn etwas schief läuft kann das Programm hängen und nicht terminieren (also der aktuelle Codeabschnitt). Der Abbruch kann versucht werden durch Drücken des Knopfes ◼.

Ein Beispiel

function foo(x)
  return x+math.random()
end
print(foo(2))

▸

◼

✗

↻

≡

Channel

Der Kommuniaktionskanal wurde bereits eingeführt. Hier noch einmal die Zusammenfassung:

Ein Channel ist entweder ein FIFO Speicher (Puffer/Queue, N Zellen) oder ein Redezvouz Kontakt (N=0)
Es gibt zwei Operatione
- Lesen (Read)
- Schreiben (Write)
Als Queue gibt es zwei Synchronisationsereignisse die zur Blockierung des aufrufenden Prozesses führen kann:
- Keine Daten im Puffer (Empty) ⇒ Read Sync
- Kein freier Platz m Puffer für neue Daten (Full) ⇒ Write Sync

Ein Beispiel: Verwendung eines Chennels in Par Prozessen

require "Csp"
local ch = Channel(1)
Par({
  function ()
    local x = ch:read()
    print("Consumed "..x)
  end,
  function ()
    local x = "Data"
    print("Producing "..x)
    ch:write(x)
  end
},{
  ch=ch
})

▸

◼

✗

↻

≡

Mit Kanälen können höhere und komplexere Kommunikationsprotokolle für die Prozesskommunikation eingesetzt werden.

Der Alt Prozesskonstruktor

Der Alt Prozesskonstruktor implemtiert einen mutualen Ausschluss auf möglicherweise parallelen Ereignissen, und führt eine Auswahl und Sequenzialisierung ein. So kann mit einem Alt Prozesse parallel auf das Eintreten von Ereignissen gewartet werden, prominent das Warten auf Daten in mehreren Kanälen.

Ein Alt Prozesskonstruktor muss immer in einen Par Prozess eingebettet werden (oder Fork oder Co), ansonsten entsteht eine permanente Blockierung des aufrufenden Prozesses (Deadlock!)
Ein Alt Prozesse besteht aus Teilprozessen mit konditionalen Vor- und Nachprozessen
Kompakte Version: Der Vorprozess ist immer die erste Anweisung, der Nachprozess alle folgenden Anweisungen.
Derzeit wird nur das Lesen aus einem Channel als konditionaler Vorprozess unterstützt.

Ein Beispiel: Verwendung eines Alt Prozesses in Par Prozessen

print('Before Alt...')
require "Csp"
local ch1 = Channel(1)
local ch2 = Channel(1)
local ch3 = Channel(1)
Par({
  function ()
    print('Alt..')
    Alt({
      function ()
        local x = ch1:read()
        print(x)
      end,
      function ()
        local x = ch2:read()
        print(x)  
      end,
      function ()
        local x = ch3:read()
        print(x)  
      end  
    })
  end,
  function (id)
    print('Master ..')
    ch1:write('A')
  end
},{
  ch1=ch1,
  ch2=ch2,
  ch3=ch3
})
print('After Alt...')

▸

◼

✗

↻

≡

Aufgabe. Welcher Wert wird ausgegeben? Was passiert wenn vor dem Alt Operator ein Wert in den Channel 2 geschrieben wird (also ch2:write("B"))?

Kommunizierende Prozesse

In dieser Aufgabe sollen mehrere Prozesse mit einem Verwaltungsprozess kommunizieren. Der Verwaltungsprozess verwaltet und verteilte geteilte Ressourcen ohne Deadlock Gefahr. Ein Beispiel ist nachfolgend die Implementierung eines Semaphor durch einen Prozess. Die anderen Prozesse fragen die Ressource über Kommunikationskanäle an, und bekommen die Antwort über einen Kommunikationskanal. Es gibt zwei Kanäle pro Prozess und Ressource:

Anfrage (Request)
Antwort (Reply)

#semchann

Mit Nachrichten kommunizierende Prozesse und zentraler Verwaltung einer Lock Ressource.

require "Csp"

local chReq = {
  Channel (1),
  Channel (1)
}
local chRep = {
  Channel (1),
  Channel (1)
}
local function lock(chReq,chRep)
  chReq:write({
    cmd = "LOCK",
    timestamp = luv.milli()
  })
  local rep = chRep:read()
  return rep
end
local function unlock(chReq,chRep)
  chReq:write({
    cmd = "UNLOCK",
    timestamp = luv.milli()
  })
  local rep = chRep:read()
  return rep
end

Par({
  function (id) 
    -- setmetatable(chreq, chreq.__class)
    -- setmetatable(chrep, chrep.__class)
    local rep = lock(chReq[id],chRep[id])
    print(rep)
    local rep = unlock(chReq[id],chRep[id])
    print(rep)
    print('End',id)
  end,
  function (id) 
    -- setmetatable(chreq, chreq.__class)
    -- setmetatable(chrep, chrep.__class)
    local rep = lock(chReq[id],chRep[id])
    print(rep)
    local rep = unlock(chReq[id],chRep[id])
    print(rep)
    print('End',id)
  end,
  function (id)
    local eos = false
    local locked = false
    local waiters = T{}
    while not eos do
      local req
      Alt({
        function (id)
          req = chReq[id]:read()
          req.index=id
        end,
        function (id)
          req = chReq[id]:read()
          req.index=id
        end        
      })
      print('Master',req.cmd,req.index)
      if (req.cmd=="LOCK") then
        if locked then
          waiters:push(req.index)
        else
          locked=true
          chRep[req.index]:write({
            cmd       = "ACK",
            timestamp = luv.milli(),
            state     = locked
          })
        end
      end
      if (req.cmd=="UNLOCK") then
        if locked then
          if #waiters>0 then
            local next = waiters:pop()
            chRep[next]:write({
              cmd       = "ACK",
              timestamp = luv.milli(),
              state     = locked
            })
            chRep[req.index]:write({
              cmd       = "ACK",
             timestamp = luv.milli(),
             state     = locked
            })
          else
            locked=false
            chRep[req.index]:write({
              cmd       = "ACK",
             timestamp = luv.milli(),
             state     = locked
            })
          end
        else
          chRep[req.index]:write({
            cmd       = "ERROR",
            timestamp = luv.milli(),
            error     = "ENOTLOCKED",
            state     = locked
          })
        end
      end      
    end
  end
},{
  chReq=chReq,
  chRep=chRep,
  lock = lock,
  unlock = unlock
})

▸

◼

✗

↻

≡

Die auskommentierten Zeilen setmetatable(chreq, chreq.__class) müssen bei lvm version < 1.15 aktiviert werden.

Aufgabe. Implementiere anstelle eines Locks ein Semaphor Objekt. Teste die Ausführung mit drei Prozessen.

Kommunizierende Dinierende Philosophen

Aufgabe. Implementiere die Dinierenden Philosophen mit einem zentralen Verwaltungsprozess der die N Gabeln verwaltet. Die Anfrage von Gabeln erfolgt über Kommunikationskanäle. Der Alt Prozesskonstruktor muss vom Verwaltungsprozess verwendet werden um auf allen Anfragekanälen Nachrichten empfangen zu können.

Implementierung der Dinierenden Philosophen ohne Deadlock mittels Alt, Par, und Kommunikationskanälen für Anfrage und Bestätigung von Ressourcen (hier die Gabeln)

local ch_p1_req = Channel(1)
local ch_p1_rep = Channel(1)
Par({
  function () 
    -- Philo 1
  end,
  function () 
    -- Philo 2
  end,
  -- ....
  function ()
    -- Verwaltung
    Alt({

    })
  end
},{

})

▸

◼

✗

↻

≡

Frage. Wie müssen die Gabeln angefragt werden damit kein Deadlock auftreten kann? Können die Gabeln sequenziell nacheinander angefragt werden? Wo wird Atomarität verletzt (siehe auch Test & Set Probleme).

Hilfe

Einreichung (Assignment #2024-90707 )

Prüfen

Bewerten (Lehrer)

Created by the NoteBook Compiler Ver. 1.27.2 (c) Dr. Stefan Bosse (Mon Jul 01 2024 09:32:02 GMT+0200 (CET))