Banker's algorithm: Difference between revisions
→{{header|Scala}}: fix typo
(→{{header|Racket}}: actual implementation added) |
(→{{header|Scala}}: fix typo) |
||
| (37 intermediate revisions by 18 users not shown) | |||
Line 1:
{{draft task|Classic CS problems
{{Wikipedia|Banker's algorithm}}
The '''Banker's algorithm''' is a [[wp:resource allocation|resource allocation]] and [[wp:deadlock|deadlock]] avoidance [[wp:algorithm|algorithm]] developed by [[wp:Edsger Dijkstra|Edsger Dijkstra]] that tests for safety by simulating the allocation of predetermined maximum possible amounts of all [[wp:resource (computer science)|resources]], and then makes a "s-state" check to test for possible deadlock conditions for all other pending activities, before deciding whether allocation should be allowed to continue.
;Example input:
Assuming that the system distinguishes between four types of resources, (A, B, C and D), the following is an example of how those resources could be distributed.
''Note that this example shows the system at an instant before a new request for resources arrives. Also, the types and number of resources are abstracted. Real systems, for example, would deal with much larger quantities of each resource.''
Total resources in system:
Line 30 ⟶ 37:
P2 0 2 0 1
P3 0 1 4 0
<br><br>
=={{header|11l}}==
{{trans|Python}}
{{todo|Python|Translate all Spanish texts to English}}
<syntaxhighlight lang="11l">V resources = Int(input(‘Cantidad de recursos: ’))
V processes = Int(input(‘Cantidad de procesos: ’))
V max_resources = input(‘Recursos máximos: ’).split_py().map(i -> Int(i))
print("\n-- recursos asignados para cada proceso --")
V currently_allocated = (0 .< processes).map(j -> input(‘proceso #.: ’.format(j + 1)).split_py().map(i -> Int(i)))
print("\n--- recursos máximos para cada proceso ---")
V max_need = (0 .< processes).map(j -> input(‘proceso #.: ’.format(j + 1)).split_py().map(i -> Int(i)))
V allocated = [0] * resources
L(i) 0 .< processes
L(j) 0 .< resources
allocated[j] += currently_allocated[i][j]
print("\nRecursos totales asignados : #.".format(allocated))
V available = (0 .< resources).map(i -> :max_resources[i] - :allocated[i])
print("Recursos totales disponibles: #.\n".format(available))
V running = [1B] * processes
V count = processes
L count != 0
V safe = 0B
L(i) 0 .< processes
I running[i]
V executing = 1B
L(j) 0 .< resources
I max_need[i][j] - currently_allocated[i][j] > available[j]
executing = 0B
L.break
I executing
print(‘proceso #. ejecutándose’.format(i + 1))
running[i] = 0B
count--
safe = 1B
L(j) 0 .< resources
available[j] += currently_allocated[i][j]
L.break
I !safe
print(‘El proceso está en un estado inseguro.’)
L.break
print("El proceso está en un estado seguro.\nRecursos disponibles: #.\n".format(available))</syntaxhighlight>
{{out}}
<pre>
Cantidad de recursos: 4
Cantidad de procesos: 3
Recursos máximos: 6 5 7 6
-- recursos asignados para cada proceso --
proceso 1: 1 2 2 1
proceso 2: 1 0 3 3
proceso 3: 1 2 1 0
--- recursos máximos para cada proceso ---
proceso 1: 3 3 2 2
proceso 2: 1 2 3 4
proceso 3: 1 3 5 0
Recursos totales asignados : [3, 4, 6, 4]
Recursos totales disponibles: [3, 1, 1, 2]
proceso 1 ejecutándose
El proceso está en un estado seguro.
Recursos disponibles: [4, 3, 3, 3]
proceso 2 ejecutándose
El proceso está en un estado seguro.
Recursos disponibles: [5, 3, 6, 6]
proceso 3 ejecutándose
El proceso está en un estado seguro.
Recursos disponibles: [6, 5, 7, 6]
</pre>
=={{header|C}}==
Line 35 ⟶ 123:
There are two <code>main()</code> functions to choose from (look for <code>#define BIG_EXAMPLE</code>), one is for task example, the other is a much heavier duty test case.
<
#include <stdbool.h>
Line 147 ⟶ 235:
return 0;
}</
{{out|Input and Output}}
<pre>Enter the number of resources: 4
Line 197 ⟶ 285:
The process is in safe state.
Available vector: 8 5 9 7</pre>
=={{header|FreeBASIC}}==
{{trans|Kotlin}}
{{todo|Python|Translate all Spanish texts to English}}
<syntaxhighlight lang="freebasic">
Dim As Integer i, j, r, p
Input "Ingrese la cantidad de recursos: ", r
Input "Ingrese la cantidad de procesos: ", p
Print !"\nIngrese los recursos m ximos: ";
Dim As Integer maxRes(r)
For i = 1 To r
Input ; " ", maxRes(i)
Next i
Print !"\n\n-- recursos asignados para cada proceso --"
Dim As Integer curr(p, r)
For i = 1 To p
Print "proceso"; i; ":";
For j = 1 To r
Input ; " ", curr(i, j)
Next j
Print
Next i
Print !"\n\n--- recursos m ximos para cada proceso ---"
Dim As Integer maxReclam(p, r)
For i = 1 To p
Print "proceso"; i; ":";
For j = 1 To r
Input ; " ", maxReclam(i, j)
Next j
Print
Next i
Print !"\nRecursos totales asignados : ";
Dim As Integer recAsigad(r)
For i = 1 To p
For j = 1 To r
recAsigad(j) += curr(i, j)
Next j
Next i
For i = 1 To r
Print recAsigad(i); " ";
Next i
Dim As Integer recDispon(r)
Print !"\n\nRecursos totales disponibles: ";
For i = 1 To r
recDispon(i) = maxRes(i) - recAsigad(i)
Print recDispon(i); " ";
Next i
Dim As Boolean ejecutando(p)
For i = 1 To p
ejecutando(i) = True
Next i
Dim As Integer contar = p
Do While contar <> 0
Dim As Boolean seguro = False
For i = 1 To p
If ejecutando(i) Then
Dim As Boolean ejecuta = True
For j = 1 To r
If (maxReclam(i,j) - curr(i,j) > recDispon(j)) Then
ejecuta = False
Exit For
End If
Next j
If ejecuta Then
Color 11 : Print !"\n\nproceso"; i; !" ejecut ndose."
ejecutando(i) = False
contar -= 1
seguro = True
For j = 0 To r
recDispon(j) += curr(i,j)
Next j
Exit For
End If
End If
Next i
If Not seguro Then
Color 12 : Print !"\nLos procesos est n en un estado inseguro."
Exit Do
End If
Color 10: Print "El proceso est en un estado seguro."
Color 7: Print "Recursos disponibles: ";
For i = 1 To r
Print recDispon(i); " ";
Next i
Loop
Sleep
</syntaxhighlight>
{{out}}
<pre>
Ingrese la cantidad de recursos: 4
Ingrese la cantidad de procesos: 3
Ingrese los recursos máximos: 6 5 7 6
-- recursos asignados para cada proceso --
proceso 1: 1 2 2 1
proceso 2: 1 0 3 3
proceso 3: 1 2 1 0
--- recursos máximos para cada proceso ---
proceso 1: 3 3 2 2
proceso 2: 1 2 3 4
proceso 3: 1 3 5 0
Recursos totales asignados : 3 4 6 4
Recursos totales disponibles: 3 1 1 2
proceso 1 ejecutándose.
El proceso está en un estado seguro.
Recursos disponibles: 4 3 3 3
proceso 2 ejecutándose.
El proceso está en un estado seguro.
Recursos disponibles: 5 3 6 6
proceso 3 ejecutándose.
El proceso está en un estado seguro.
Recursos disponibles: 6 5 7 6
</pre>
=={{header|Go}}==
WP cites EWD-108 and has EWD-623 as further reading. In using the analogy of a money, EWD-108 considers only a single type of resource. EWD-623 seems mostly in terms of a single resource but a couple of times says "all resources." This subtly hints that the algorithm can be adapted for multiple resource types. WP then gives an array-based presentation that works for multiple resources.
This solution is more inspired by EWD-623 than WP. EWD-623, while it talks of finding a permutation of processes, notes that the "ordering effort" can be stopped as soon as the process requesting resources happens to be found satisfiable. The solution here attempts to make this finding as soon as possible by moving the process to the front of a list of unsatisfied processes. Also since the solved permutation of satisfied processes has no use, it is not kept which simplifies the algorithm a bit.
<syntaxhighlight lang="go">package bank
import (
"bytes"
"errors"
"fmt"
"log"
"sort"
"sync"
)
type PID string
type RID string
type RMap map[RID]int
// format RIDs in order
func (m RMap) String() string {
rs := make([]string, len(m))
i := 0
for r := range m {
rs[i] = string(r)
i++
}
sort.Strings(rs)
var b bytes.Buffer
b.WriteString("{")
for _, r := range rs {
fmt.Fprintf(&b, "%q: %d, ", r, m[RID(r)])
}
bb := b.Bytes()
if len(bb) > 1 {
bb[len(bb)-2] = '}'
}
return string(bb)
}
type Bank struct {
available RMap
max map[PID]RMap
allocation map[PID]RMap
sync.Mutex
}
func (b *Bank) need(p PID, r RID) int {
return b.max[p][r] - b.allocation[p][r]
}
func New(available RMap) (b *Bank, err error) {
for r, a := range available {
if a < 0 {
return nil, fmt.Errorf("negative resource %s: %d", r, a)
}
}
return &Bank{
available: available,
max: map[PID]RMap{},
allocation: map[PID]RMap{},
}, nil
}
func (b *Bank) NewProcess(p PID, max RMap) (err error) {
b.Lock()
defer b.Unlock()
if _, ok := b.max[p]; ok {
return fmt.Errorf("process %s already registered", p)
}
for r, m := range max {
switch a, ok := b.available[r]; {
case !ok:
return fmt.Errorf("resource %s unknown", r)
case m > a:
return fmt.Errorf("resource %s: process %s max %d > available %d",
r, p, m, a)
}
}
b.max[p] = max
b.allocation[p] = RMap{}
return
}
func (b *Bank) Request(pid PID, change RMap) (err error) {
b.Lock()
defer b.Unlock()
if _, ok := b.max[pid]; !ok {
return fmt.Errorf("process %s unknown", pid)
}
for r, c := range change {
if c < 0 {
return errors.New("decrease not allowed")
}
if _, ok := b.available[r]; !ok {
return fmt.Errorf("resource %s unknown", r)
}
if c > b.need(pid, r) {
return errors.New("increase exceeds declared max")
}
}
// allocation is non-exported data so we can change it in place
// then change it back if the request cannot be granted.
for r, c := range change {
b.allocation[pid][r] += c // change in place
}
defer func() {
if err != nil { // if request not granted,
for r, c := range change {
b.allocation[pid][r] -= c // change it back
}
}
}()
// Collect list of process IDs, also compute cash
// First in the list is always the requesting PID.
cash := RMap{}
for r, a := range b.available {
cash[r] = a
}
perm := make([]PID, len(b.allocation))
i := 1
for pr, a := range b.allocation {
if pr == pid {
perm[0] = pr
} else {
perm[i] = pr
i++
}
for r, a := range a {
cash[r] -= a
}
}
ret := RMap{} // sum of loans
m := len(perm) // number of processes still candidates for termination
for {
// find a process h that can terminate
h := 0
h:
for ; ; h++ {
if h == m {
// no process could terminate
return errors.New("request would make deadlock possible")
}
for r := range b.available {
if b.need(perm[h], r) > cash[r]+ret[r] {
// h cannot terminate if any resource need cannot be met.
continue h
}
}
// log possible terimation, consistent with WP example program.
log.Println(" ", perm[h], "could terminate")
// all resource needs can be met. h can terminate.
break
}
if h == 0 { // Zwanenburg condition:
// if requesting process can terminate, pattern is safe and
// remaining terminations do not need to be demonstrated.
return nil
}
for r, a := range b.allocation[perm[h]] {
ret[r] += a
}
m--
perm[h] = perm[m]
}
}</syntaxhighlight>
<syntaxhighlight lang="go">package main
import (
"fmt"
"bank"
)
func main() {
// Task example data:
// create "bank" with available resources
b, _ := bank.New(bank.RMap{"A": 6, "B": 5, "C": 7, "D": 6})
// add processes with their maximum allocation limits
b.NewProcess("P1", bank.RMap{"A": 3, "B": 3, "C": 2, "D": 2})
b.NewProcess("P2", bank.RMap{"A": 1, "B": 2, "C": 3, "D": 4})
b.NewProcess("P3", bank.RMap{"A": 1, "B": 3, "C": 5})
// processes request resources. Each request is checked for safety.
// <nil> returned error value means request was safe and was granted.
fmt.Println("P1 request:")
fmt.Println(b.Request("P1", bank.RMap{"A": 1, "B": 2, "C": 2, "D": 1}))
fmt.Println("\nP2 request:")
fmt.Println(b.Request("P2", bank.RMap{"A": 1, "C": 3, "D": 3}))
fmt.Println("\nP3 request:")
fmt.Println(b.Request("P3", bank.RMap{"A": 1, "B": 2, "C": 1}))
}</syntaxhighlight>
{{out}}
<pre>
P1 request:
2017/08/29 16:44:15 P1 could terminate
<nil>
P2 request:
2017/08/29 16:44:15 P2 could terminate
<nil>
P3 request:
2017/08/29 16:44:15 P1 could terminate
2017/08/29 16:44:15 P2 could terminate
2017/08/29 16:44:15 P3 could terminate
<nil>
</pre>
=={{header|J}}==
The task description currently does not define the process being run. So we follow the example set by other implementations and have each process free all resources after successfully being run. Also, since this is a demo, we give a blow-by-blow description of what's happening as it runs.
<syntaxhighlight lang="j">bankrun=:1 :0
'MAX ALLOC TOTAL'=. y
todo=.(#ALLOC)#1
whilst. (+./todo)*-. prior-:todo do.
prior=. todo
for_p.I.todo do.
avail=. TOTAL-+/ALLOC
echo 'currently available: ',":avail
pALLOC=. p{ALLOC
pMAX=. p{MAX
request=. pMAX-pALLOC
if.(0>request)+.&(+./)request>avail do.
echo 'unsafe request ',(":request),', skipping ',":p
continue.
else.
echo 'running process ',(":p),', allocating ',":request
end.
free=.request u pALLOC
echo 'process ',(":p),' freeing ',":free
assert (0<:free) *&(*/) free <: pMAX
ALLOC=. (pALLOC-free) p} ALLOC
todo=. 0 p} todo
end.
end.
if.+./todo do.
echo 'deadlocked processes: ',":I.todo
end.
echo 'DONE'
)</syntaxhighlight>
Definitions for task example:
<syntaxhighlight lang="j">max=: 3 3 2 2,1 2 3 4,:1 3 5 0
alloc=: 1 2 2 1,1 0 3 3,:1 2 1 0
total=:6 5 7 6
NB. simulate running process
NB. left arg: newly available resources, right: previously available
NB. result: resources freed
run=: +</syntaxhighlight>
Example run:
<syntaxhighlight lang="j"> run bankrun max;alloc;total
currently available: 3 1 1 2
running process 0, allocating 2 1 0 1
process 0 freeing 3 3 2 2
currently available: 6 4 3 4
running process 1, allocating 0 2 0 1
process 1 freeing 1 2 3 4
currently available: 7 6 6 8
running process 2, allocating 0 1 4 0
process 2 freeing 1 3 5 0
DONE</syntaxhighlight>
=={{header|Julia}}==
{{trans|Kotlin}}
<syntaxhighlight lang="julia">function queryprompt(query, typ)
print(query, ": ")
entry = uppercase(strip(readline(stdin)))
return (typ <: Integer) ? parse(Int, entry) :
(typ <: Vector) ? map(x -> parse(Int, x), split(entry, r"\s+")) :
entry
end
function testbankers()
r = queryprompt("Enter the number of resources", Int)
p = queryprompt("\nEnter the number of processes", Int)
maxres = queryprompt("\nEnter Claim Vector", Vector{Int})
curr, maxclaim = zeros(Int, p, r), zeros(Int, p, r)
for i in 1:p
curr[i, :] .= queryprompt("\nEnter Allocated Resource Table, Row $i", Vector{Int})
end
for i in 1:p
maxclaim[i, :] .= queryprompt("\nEnter Maximum Claim Table, Row $i", Vector{Int})
end
alloc = [sum(curr[:, j]) for j in 1:r]
println("\nAllocated Resources: $alloc")
avl = map(i -> maxres[i] - alloc[i], 1:r)
println("\nAvailable Resources: $avl")
running = trues(p)
count = p
while count != 0
safe = false
for i in 1:p
if running[i]
exec = true
for j in 1:r
if maxclaim[i, j] - curr[i, j] > avl[j]
exec = false
break
end
end
if exec
println("\nProcess $i is executing.")
running[i] = false
count -= 1
safe = true
for j in 1:r
avl[j] += curr[i, j]
end
break
end
end
end
if !safe
println("The processes are in an unsafe state.")
break
end
println("\nThe process is in a safe state.")
println("\nAvailable Vector: $avl")
end
end
testbankers()
</syntaxhighlight>{{out}}
<pre>
Enter the number of resources: 4
Enter the number of processes: 5
Enter Claim Vector: 8 5 9 7
Enter Allocated Resource Table, Row 1: 2 0 1 1
Enter Allocated Resource Table, Row 2: 0 1 2 1
Enter Allocated Resource Table, Row 3: 4 0 0 3
Enter Allocated Resource Table, Row 4: 0 2 1 0
Enter Allocated Resource Table, Row 5: 1 0 3 0
Enter Maximum Claim Table, Row 1: 3 2 1 4
Enter Maximum Claim Table, Row 2: 0 2 5 2
Enter Maximum Claim Table, Row 3: 5 1 0 5
Enter Maximum Claim Table, Row 4: 1 5 3 0
Enter Maximum Claim Table, Row 5: 3 0 3 3
Allocated Resources: [7, 3, 7, 5]
Available Resources: [1, 2, 2, 2]
Process 3 is executing.
The process is in a safe state.
Available Vector: [5, 2, 2, 5]
Process 1 is executing.
The process is in a safe state.
Available Vector: [7, 2, 3, 6]
Process 2 is executing.
The process is in a safe state.
Available Vector: [7, 3, 5, 7]
Process 4 is executing.
The process is in a safe state.
Available Vector: [7, 5, 6, 7]
Process 5 is executing.
The process is in a safe state.
Available Vector: [8, 5, 9, 7]
</pre>
=={{header|Kotlin}}==
{{trans|C}}
For simplicity, input checking is ignored:
<syntaxhighlight lang="scala">// version 1.1.4-3
fun main(args: Array<String>) {
print("Enter the number of resources: ")
val r = readLine()!!.toInt()
print("\nEnter the number of processes: ")
val p = readLine()!!.toInt()
print("\nEnter Claim Vector: ")
val maxRes = readLine()!!.split(' ').map { it.toInt() } .toIntArray()
println("\nEnter Allocated Resource Table:")
val curr = Array(p) { IntArray(r) }
for (i in 0 until p) {
print("Row ${i + 1}: ")
curr[i] = readLine()!!.split(' ').map { it.toInt() }.toIntArray()
}
println("\nEnter Maximum Claim Table: ")
val maxClaim = Array(p) { IntArray(r) }
for (i in 0 until p) {
print("Row ${i + 1}: ")
maxClaim[i] = readLine()!!.split(' ').map { it.toInt() }.toIntArray()
}
val alloc = IntArray(r)
for (i in 0 until p) {
for (j in 0 until r) alloc[j] += curr[i][j]
}
println("\nAllocated Resources: ${alloc.joinToString(" ")}")
val avl = IntArray(r) { maxRes[it] - alloc[it] }
println("\nAvailable Resources: ${avl.joinToString(" ")}")
val running = BooleanArray(p) { true }
var count = p
while (count != 0) {
var safe = false
for (i in 0 until p) {
if (running[i]) {
var exec = true
for (j in 0 until r) {
if (maxClaim[i][j] - curr[i][j] > avl[j]) {
exec = false
break
}
}
if (exec) {
print("\nProcess ${i + 1} is executing.\n")
running[i] = false
count--
safe = true
for (j in 0 until r) avl[j] += curr[i][j]
break
}
}
}
if (!safe) {
print("The processes are in an unsafe state.")
break
}
print("\nThe process is in a safe state.")
println("\nAvailable Vector: ${avl.joinToString(" ")}")
}
}</syntaxhighlight>
Sample input/output:
<pre>
Enter the number of resources: 4
Enter the number of processes: 5
Enter Claim Vector: 8 5 9 7
Enter Allocated Resource Table:
Row 1: 2 0 1 1
Row 2: 0 1 2 1
Row 3: 4 0 0 3
Row 4: 0 2 1 0
Row 5: 1 0 3 0
Enter Maximum Claim Table:
Row 1: 3 2 1 4
Row 2: 0 2 5 2
Row 3: 5 1 0 5
Row 4: 1 5 3 0
Row 5: 3 0 3 3
Allocated Resources: 7 3 7 5
Available Resources: 1 2 2 2
Process 3 is executing.
The process is in a safe state.
Available Vector: 5 2 2 5
Process 1 is executing.
The process is in a safe state.
Available Vector: 7 2 3 6
Process 2 is executing.
The process is in a safe state.
Available Vector: 7 3 5 7
Process 4 is executing.
The process is in a safe state.
Available Vector: 7 5 6 7
Process 5 is executing.
The process is in a safe state.
Available Vector: 8 5 9 7
</pre>
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module BankerAlgo {
Form 80, 44
Cls 5
Pen 14
Function Request(FromWhere as Inventory, What$, Many as long) {
=FromWhere(What$)-FromWhere(What$+"_Request")-Many>=0
}
Function RequestPreset(FromWhere as Inventory, What$, Many as long) {
=FromWhere(What$+"_Request")-Many>=0
}
Function Need(FromWhere as Inventory, What$, Many) {
=FromWhere(What$ + "_max")-FromWhere(What$)-Many>=0
}
\\ code for sub can be found from parent module/function (here parent as in code, not as in call)
Function NewProcess {
Inventory Process
ApplyResources(Process) ' sub need more arguments and read from current stack
=Process
}
Inventory System, Processes
\\ Recource, Max, Available
ApplyResources(System, "A", 6, 3,"B", 5,1,"C", 7, 1, "D", 6, 2)
\\ Recource, Max, Available
Append Processes, "P1":=NewProcess("A", 3, 1, "B", 3, 2, "C", 2, 2, "D", 2,1)
Append Processes, "P2":=NewProcess("A", 1, 1, "B", 2, 0, "C", 3, 3, "D", 4,3)
Append Processes, "P3":=NewProcess("A", 1, 1, "B", 3, 2, "C", 5, 1, "D", 0,0)
Status(True) ' show all process, available resource and max
SafeState=True
Print "Current Status"
RequestResource() ' display Safe State
RequestResource("P2", "D", 1) ' display Safe State
RequestResource("P1", "A", 1, "D", 1) ' display Safe State
RequestResource("P1", "C", 1, "D", 1) ' display Too many resources ...
RequestResource("P2", "B", 1) ' display Unsafe State
RequestResource("P3", "C", 1) ' display Safe State
Status()
\\ Second Example
Clear System, Processes
ApplyResources(System, "A", 10, 3)
Append Processes, "P1":=NewProcess("A", 9, 3)
Append Processes, "P2":=NewProcess("A", 4, 2)
Append Processes, "P3":=NewProcess("A", 7, 2)
Status(True) ' show all process, available resource and max
Print "Current Status"
RequestResource() ' display Safe State
\ Third Example
Clear System
ApplyResources(System, "A", 10, 2)
Return Processes, "P1":=NewProcess("A", 9,4)
Status(True) ' show all process, available resource and max
Print "Current Status"
RequestResource() ' display UnSafe State
Sub Respond()
If SafeState Then {
Pen 15 {Print "Safe State"}
} Else Pen 13 {Print "Unsafe State"}
End Sub
Sub WaitForKey()
Pen 11 {Print "Press a key"}
local a$=key$
End Sub
Sub RequestResource(ProcessName$="" )
SafeState=True
If ProcessName$="" Then CheckNewState(&SafeState) : Respond() : Print : WaitForKey():Exit Sub
Local pro=Processes(ProcessName$), ResourceName$, many as long
ClearAllRequest(pro)
Local skip=False
While Match("SN") {
Read ResourceName$, many
Print Format$("Claim {1} for type {0} resource ",ResourceName$, many)
If skip Then Continue
If Request(System, ResourceName$, many) Then {
If Need(pro, ResourceName$, many) Then {
Return pro, ResourceName$+"_Request":=many
Return System, ResourceName$+"_Request":=-many
} Else {
Print "Too many Recources "+ResourceName$+" for Process "+ProcessName$ : Skip=True
}
} Else Print "Too many Recources for System" : Skip=True
If Skip Then exit
}
If skip Else CheckNewState(&SafeState) : Respond()
Print ' just a new line
WaitForKey()
End Sub
Sub ApplyResources(Where as Inventory, What$, MaxValue, InitialValue)
Repeat {
If Not Exist(Where, What$) Then {
Append Where, What$:=InitialValue, What$+"_max":=MaxValue, What$+"_Request":=0
}
If not Match("SNN") Then Exit
Read What$, MaxValue, InitialValue
} Always
End Sub
Sub ClearAllRequest(Where as Inventory)
Local M=Each(Where)
While M {
If Instr(Eval$(M, M^),"_")=0 Then {
Return Where, Eval$(M,M^)+"_Request":=0
}
}
End Sub
Sub PrintResources(Where as Inventory)
Local M=Each(Where)
While M {
If Instr(Eval$(M, M^),"_")=0 Then Print Eval$(M, M^)+"="+Eval$(M),
}
Print
Exit Sub
Sub PrintMax(Where as Inventory)
Local M=Each(Where)
While M {
If Instr(Eval$(M, M^),"_max")>0 Then Print LeftPart$(Eval$(M, M^), "_")+"="+Eval$(M),
}
Print
Exit Sub
Sub Status(Ok as boolean=False)
Print "Total System Resources"
PrintMax(System)
Print "Available Resources in System"
PrintResources(System)
If Not Ok Then WaitForKey(): Exit Sub
Local M=Each(Processes)
While M {
Print "Process "+Eval$(M, M^)
PrintResources(Processes(M^!)) ' give index M^ as Key index number (using !)
Print "Maximum Resources for "+Eval$(M, M^)
PrintMax(Processes(M^!))
}
End Sub
Sub CheckNewState(&Ok)
local M=Each(Processes), M1, count=len(Processes), alive(0 to count-1)=1
Local Z, Recource$, safe as boolean=false
While count {
safe=false
While M {
If alive(M^) Then {
Z=Processes(M^!)
M1=Each(Z)
safe=True
While M1 {
Recource$=Eval$(M1, M1^)
If Instr(Recource$,"_")=0 Then {
safe=System(Recource$)+System(Recource$+"_Request") >= Z(Recource$ + "_max") - Z(Recource$)-Z(Recource$ + "_Request")
}
If not safe Then exit
}
If safe Then {
print format$("Process {0} is executing", M^+1)
alive(M^)=0
count--
M1=Each(Z)
While M1 {
Recource$=Eval$(M1, M1^)
If Instr(Recource$,"_")=0 Then {
Return System, Recource$+"_Request":= System(Recource$+"_Request") + Z(Recource$) + Z(Recource$+"_Request")
Return Z, Recource$+"_Request":=0
}
}
}
}
}
If safe Else exit
}
Ok=safe
ClearAllRequest(System)
End Sub
}
BankerAlgo</syntaxhighlight>
=={{header|Nim}}==
{{trans|Kotlin}}
<syntaxhighlight lang="nim">import sequtils, strformat, strutils, sugar
stdout.write "Enter the number of resources: "
let r = stdin.readLine().parseInt()
stdout.write "Enter the number of processes: "
stdout.flushFile()
let p = stdin.readLine().parseInt()
stdout.write "Enter Claim Vector: "
let maxRes = stdin.readLine().splitWhitespace().map(parseInt)
echo "Enter Allocated Resource Table:"
var curr = newSeqWith(p, newSeq[int](r))
for i in 0..<p:
stdout.write &"Row {i + 1}: "
curr[i] = stdin.readLine().splitWhitespace().map(parseInt)
echo "Enter Maximum Claim Table:"
var maxClaim = newSeqWith(p, newSeq[int](r))
for i in 0..<p:
stdout.write &"Row {i + 1}: "
maxClaim[i] = stdin.readLine().splitWhitespace().map(parseInt)
var alloc = newSeq[int](r)
for i in 0..<p:
for j in 0..<r:
alloc[j] += curr[i][j]
echo &"\nAllocated Resources: {alloc.join(\" \")}"
var avl = collect(newSeq, for i in 0..<r: maxRes[i] - alloc[i])
echo &"Available Resources: {avl.join(\" \")}"
var running = repeat(true, p)
var count = p
while count > 0:
var safe = false
for i in 0..<p:
if running[i]:
var exec = true
for j in 0..<r:
if maxClaim[i][j] - curr[i][j] > avl[j]:
exec = false
break
if exec:
echo &"\nProcess {i + 1} is executing."
running[i] = false
dec count
safe = true
for j in 0..<r: avl[j] += curr[i][j]
break
if not safe:
echo "The processes are in an unsafe state."
break
echo "\nThe process is in a safe state."
echo &"Available Vector: {avl.join(\" \")}"</syntaxhighlight>
{{out}}
<pre>Enter the number of resources: 4
Enter the number of processes: 5
Enter Claim Vector: 8 5 9 7
Enter Allocated Resource Table:
Row 1: 2 0 1 1
Row 2: 0 1 2 1
Row 3: 4 0 0 3
Row 4: 0 2 1 0
Row 5: 1 0 3 0
Enter Maximum Claim Table:
Row 1: 3 2 1 4
Row 2: 0 2 5 2
Row 3: 5 1 0 5
Row 4: 1 5 3 0
Row 5: 3 0 3 3
Allocated Resources: 7 3 7 5
Available Resources: 1 2 2 2
Process 3 is executing.
The process is in a safe state.
Available Vector: 5 2 2 5
Process 1 is executing.
The process is in a safe state.
Available Vector: 7 2 3 6
Process 2 is executing.
The process is in a safe state.
Available Vector: 7 3 5 7
Process 4 is executing.
The process is in a safe state.
Available Vector: 7 5 6 7
Process 5 is executing.
The process is in a safe state.
Available Vector: 8 5 9 7</pre>
=={{header|Perl}}==
{{trans|Raku}}
<syntaxhighlight lang="perl">use strict;
use warnings;
use feature 'say';
my @avail = (3, 1, 1, 2); # Available instances of resource
my @maxm = ([3, 3, 2, 2], [1, 2, 3, 4], [1, 3, 5, 0]); # Maximum R that can be allocated to processes
my @allot = ([1, 2, 2, 1], [1, 0, 3, 3], [1, 2, 1, 0]); # Resources allocated to processes
# Function to find the system is in safe state or not
sub isSafe {
my($work, $maxm, $allot) = @_;
my $P = @$allot; # Number of processes
my $R = @$work; # Number of resources
my @unfinished = (1) x $P; # Mark all processes as unfinished
my(@safeSeq,@need);
for my $i (0..$P-1) { # Calculating need of each process:
for my $j (0..$R-1) { # maxm instance - allocated instance
$need[$i][$j] = $$maxm[$i][$j] - $$allot[$i][$j]
}
}
# While all processes are not finished or system is not in safe state
my $count = 0;
while ($count < $P) {
my $found = 0;
for my $p (0..$P-1) {
# While a process is not finished
if ($unfinished[$p]) {
# Check if for all resources of current P need is less than work
my $satisfied;
LOOP: for my $j (0..$R-1) {
$satisfied = $j;
last LOOP if $need[$p][$j] > $$work[$j]
}
# If all needs of p were satisfied
if ($satisfied == $R-1) {
$$work[$_] += $$allot[$p][$_] for 0..$R-1; # free the resources
say 'available resources: ' . join ' ', @$work;
push @safeSeq, $p; # Add this process to safe sequence
$unfinished[$p] = 1; # Mark this process as finished
$count += 1;
$found = 1
}
}
}
# If we could not find a next process in safe sequence.
return 0, "System is not in safe state." unless $found;
}
# If system is in safe state then safe sequence will be as below
return 1, "Safe sequence is: " . join ' ', @safeSeq
}
# Check system is in safe state or not
my($safe_state,$status_message) = isSafe(\@avail, \@maxm, \@allot);
say "Safe state? " . ($safe_state ? 'True' : 'False');
say "Message: $status_message";</syntaxhighlight>
{{out}}
<pre>available resources: 4 3 3 3
available resources: 5 3 6 6
available resources: 6 5 7 6
Safe state? True
Message: Safe sequence is: 0 1 2</pre>
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">max_res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">5</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">7</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">6</span><span style="color: #0000FF;">},</span>
<span style="color: #000000;">curr</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">}},</span>
<span style="color: #000000;">running</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">curr</span><span style="color: #0000FF;">)),</span>
<span style="color: #000000;">max_claim</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{{</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">4</span><span style="color: #0000FF;">},</span>
<span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">3</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">5</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">}},</span>
<span style="color: #000000;">alloc</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">max_res</span><span style="color: #0000FF;">))</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">count</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">curr</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">count</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">alloc</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sq_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">alloc</span><span style="color: #0000FF;">,</span><span style="color: #000000;">curr</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">avl</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sq_sub</span><span style="color: #0000FF;">(</span><span style="color: #000000;">max_res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">alloc</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Available system resources: %V\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">max_res</span><span style="color: #0000FF;">})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Process allocated: %V\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">curr</span><span style="color: #0000FF;">})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Maximum resources: %V\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">max_claim</span><span style="color: #0000FF;">})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Allocated resources: %V\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">alloc</span><span style="color: #0000FF;">})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Available resources: %V\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">avl</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">count</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">bool</span> <span style="color: #000000;">safe</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">curr</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">running</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span>
<span style="color: #004080;">bool</span> <span style="color: #000000;">execute</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">true</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">max_res</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">max_claim</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">][</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]-</span><span style="color: #000000;">curr</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">][</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">></span> <span style="color: #000000;">avl</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">execute</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>
<span style="color: #008080;">exit</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">execute</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Process%d is executing. "</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">running</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>
<span style="color: #000000;">count</span> <span style="color: #0000FF;">-=</span> <span style="color: #000000;">1</span>
<span style="color: #000000;">safe</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">true</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">max_res</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">avl</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">curr</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">][</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">exit</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">if</span> <span style="color: #008080;">not</span> <span style="color: #000000;">safe</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"The processes are in an unsafe state.\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">exit</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Safe state. Available resources: %V\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">avl</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Available system resources: {6,5,7,6}
Process allocated: {{1,2,2,1},{1,0,3,3},{1,2,1,0}}
Maximum resources: {{3,3,2,2},{1,2,3,4},{1,3,5,0}}
Allocated resources: {3,4,6,4}
Available resources: {3,1,1,2}
Process1 is executing. Safe state. Available resources: {4,3,3,3}
Process2 is executing. Safe state. Available resources: {5,3,6,6}
Process3 is executing. Safe state. Available resources: {6,5,7,6}
</pre>
Changing the initial curr[2] to {1, 1, 3, 3}:
<pre>
Available system resources: {6,5,7,6}
Process allocated: {{1,2,2,1},{1,1,3,3},{1,2,1,0}}
Maximum resources: {{3,3,2,2},{1,2,3,4},{1,3,5,0}}
Allocated resources: {3,5,6,4}
Available resources: {3,0,1,2}
The processes are in an unsafe state.
</pre>
=={{header|Python}}==
<syntaxhighlight lang="python">
def main():
resources = int(input("Number of resources: "))
processes = int(input("Number of processes: "))
max_resources = [int(i) for i in input("Maximum resources: ").split()]
print("\n-- resources allocated for each process --")
currently_allocated = [[int(i) for i in input(f"process {j + 1}: ").split()] for j in range(processes)]
print("\n--- maximum resources for each process ---")
max_need = [[int(i) for i in input(f"process {j + 1}: ").split()] for j in range(processes)]
allocated = [0] * resources
for i in range(processes):
for j in range(resources):
allocated[j] += currently_allocated[i][j]
print(f"\nTotal resources allocated: {allocated}")
available = [max_resources[i] - allocated[i] for i in range(resources)]
print(f"Total resources available: {available}\n")
running = [True] * processes
count = processes
while count != 0:
safe = False
for i in range(processes):
if running[i]:
executing = True
for j in range(resources):
if max_need[i][j] - currently_allocated[i][j] > available[j]:
executing = False
break
if executing:
print(f"process {i + 1} running")
running[i] = False
count -= 1
safe = True
for j in range(resources):
available[j] += currently_allocated[i][j]
break
if not safe:
print("The process is in an unsafe state.")
break
print(f"The process is in a safe state.\nAvailable resources: {available}\n\n")
if __name__ == '__main__':
main()
</syntaxhighlight>
{{out}}
<pre>
Number of resources: 4
Number of processes: 3
Maximum resources: 6 5 7 6
-- resources allocated for each process --
process 1: 1 2 2 1
process 2: 1 0 3 3
process 3: 1 2 1 0
--- maximum resources for each process ---
process 1: 3 3 2 2
process 2: 1 2 3 4
process 3: 1 3 5 0
Total resources allocated: [3, 4, 6, 4]
Total resources available: [3, 1, 1, 2]
process 1 running
The process is in a safe state.
Available resources: [4, 3, 3, 3]
process 2 running
The process is in a safe state.
Available resources: [5, 3, 6, 6]
process 3 running
The process is in a safe state.
Available resources: [6, 5, 7, 6]
</pre>
=={{header|Racket}}==
<
(require racket/block racket/pretty racket/port racket/vector)
Line 284 ⟶ 1,534:
EOS
(λ () (call-with-values bankers-input bankers-algorithm))))</
{{out}}
Line 331 ⟶ 1,581:
Available vector: '#(8 5 9 7)</pre>
=={{header|Raku}}==
(formerly Perl 6)
Based on the Python3 solution by Shubham Singh found
[https://www.geeksforgeeks.org/program-bankers-algorithm-set-1-safety-algorithm/ here]
<syntaxhighlight lang="raku" line>my @avail = <3 1 1 2>; # Available instances of resource
my @maxm = <3 3 2 2>, <1 2 3 4>, <1 3 5 0>; # Maximum resources that can be allocated to processes
my @allot = <1 2 2 1>, <1 0 3 3>, <1 2 1 0>; # Resources allocated to processes
# Function to find the system is in safe state or not
sub isSafe(\work is copy, \maxm, \allot) {
my \P = allot.elems; # Number of processes
my \Pool = (^P).SetHash; # Process pool
my \R = work.elems; # Number of resources
my \need = maxm »-« allot; # the need matrix
my @safe-sequence;
# While all processes are not finished or system is not in safe state
my $count = 0;
while $count < P {
my $found = False;
for Pool.keys -> \p {
if all need[p] »≤« work { # now process can be finished
work »+=« allot[p;^R]; # Free the resources
say 'available resources: ' ~ work;
@safe-sequence.push: p; # Add this process to safe sequence
Pool{p}--; # Remove this process from Pool
$count += 1;
$found = True
}
}
# If we could not find a next process in safe sequence
return False, "System is not in safe state." unless $found;
}
# If system is in safe state then safe sequence will be as below
return True, "Safe sequence is: " ~ @safe-sequence
}
# Check if system is in a safe state
my ($safe-state,$status-message) = isSafe @avail, @maxm, @allot;
say "Safe state? $safe-state";
say "Message: $status-message";</syntaxhighlight>
{{out}}
<pre>available resources: 4 3 3 3
available resources: 5 3 6 6
available resources: 6 5 7 6
Safe state? True
Message: Safe sequence is: 0 1 2</pre>
=={{header|Rust}}==
Adapted from the C language version. It crashes for invalid input.
<syntaxhighlight lang="rust">
fn read_numbers<T>() -> Vec<T>
where T: std::str::FromStr {
use std::io::Write;
std::io::stdout().flush().unwrap();
let mut line = String::new();
std::io::stdin().read_line(&mut line).unwrap();
line.split(" ").map(|word| word.trim().parse::<T>().ok().unwrap()).collect()
}
fn main() {
print!("Enter the number of resources: ");
let r = read_numbers()[0];
print!("Enter the number of processes: ");
let p = read_numbers()[0];
let mut running = vec![true; p];
let mut count = p;
print!("Enter the {}-item claim vector: ", r);
let max_res = read_numbers::<u32>();
println!("Enter the {}-line {}-column allocated-resource table:", p, r);
let mut curr = vec![vec![0; 0]; p];
for i in 0..p {
curr[i] = read_numbers::<u32>();
}
println!("Enter the {}-line {}-column maximum-claim table:", p, r);
let mut max_claim = vec![vec![0; 0]; p];
for i in 0..p {
max_claim[i] = read_numbers::<u32>();
}
print!("The claim vector is: ");
for i in 0..r {
print!("{} ", max_res[i]);
}
println!();
println!("The allocated resources table is:");
for i in 0..p {
for j in 0..r {
print!("\t{}", curr[i][j]);
}
println!();
}
println!("The maximum claims table is:");
for i in 0..p {
for j in 0..r {
print!("\t{}", max_claim[i][j]);
}
println!();
}
let mut alloc = vec![0; r];
for i in 0..p {
for j in 0..r {
alloc[j] += curr[i][j];
}
}
print!("The allocated resources are: ");
for i in 0..r {
print!("{} ", alloc[i]);
}
println!();
let mut avl = vec![0; r];
for i in 0..r {
avl[i] = max_res[i] - alloc[i];
}
print!("The available resources are: ");
for i in 0..r {
print!("{} ", avl[i]);
}
println!();
while count != 0 {
let mut safe = false;
for i in 0..p {
if running[i] {
let mut exec = true;
for j in 0..r {
if max_claim[i][j] - curr[i][j] > avl[j] {
exec = false;
break;
}
}
if exec {
println!("Process {} is executing.", i + 1);
running[i] = false;
count -= 1;
safe = true;
for j in 0..r {
avl[j] += curr[i][j];
}
break;
}
}
}
if safe {
println!("The process is in safe state.");
}
else {
println!("The processes are in unsafe state.");
break;
}
print!("The available vector is: ");
for i in 0..r {
print!("{} ", avl[i]);
}
println!();
}
}</syntaxhighlight>
{{out|Input and Output}}
<pre>
Enter the number of resources: 4
Enter the number of processes: 5
Enter the 4-item claim vector: 8 5 9 7
Enter the 5-line 4-column allocated-resource table:
2 0 1 1
0 1 2 1
4 0 0 3
0 2 1 0
1 0 3 0
Enter the 5-line 4-column maximum-claim table:
3 2 1 4
0 2 5 2
5 1 0 5
1 5 3 0
3 0 3 3
The claim vector is: 8 5 9 7
The allocated resources table is:
2 0 1 1
0 1 2 1
4 0 0 3
0 2 1 0
1 0 3 0
The maximum claims table is:
3 2 1 4
0 2 5 2
5 1 0 5
1 5 3 0
3 0 3 3
The allocated resources are: 7 3 7 5
The available resources are: 1 2 2 2
Process 3 is executing.
The process is in safe state.
The available vector is: 5 2 2 5
Process 1 is executing.
The process is in safe state.
The available vector is: 7 2 3 6
Process 2 is executing.
The process is in safe state.
The available vector is: 7 3 5 7
Process 4 is executing.
The process is in safe state.
The available vector is: 7 5 6 7
Process 5 is executing.
The process is in safe state.
The available vector is: 8 5 9 7
</pre>
=={{header|Scala}}==
{{trans|Python}}
<syntaxhighlight lang="Scala">
import scala.io.StdIn.readLine
object BankersAlgorithm {
def main(args: Array[String]): Unit = {
println("Number of resources: ")
val resources = readLine().toInt
println("Number of processes: ")
val processes = readLine().toInt
println("Maximum resources: ")
val maxResources = readLine().split(" ").map(_.toInt)
println("\n-- resources allocated for each process --")
val currentlyAllocated = Array.ofDim[Int](processes, resources)
for (i <- 0 until processes) {
println(s"process ${i + 1}: ")
currentlyAllocated(i) = readLine().split(" ").map(_.toInt)
}
println("\n--- maximum resources for each process ---")
val maxNeed = Array.ofDim[Int](processes, resources)
for (i <- 0 until processes) {
println(s"process ${i + 1}: ")
maxNeed(i) = readLine().split(" ").map(_.toInt)
}
val allocated = Array.fill(resources)(0)
for (i <- 0 until processes) {
for (j <- 0 until resources) {
allocated(j) += currentlyAllocated(i)(j)
}
}
println(s"\nTotal resources allocated: ${allocated.mkString(", ")}")
val available = maxResources.zip(allocated).map { case (max, alloc) => max - alloc }
println(s"Total resources available: ${available.mkString(", ")}\n")
var running = Array.fill(processes)(true)
var count = processes
while (count != 0) {
var safe = false
for (i <- 0 until processes if running(i)) {
var executing = true
for (j <- 0 until resources) {
if (maxNeed(i)(j) - currentlyAllocated(i)(j) > available(j)) {
executing = false
}
}
if (executing) {
println(s"process ${i + 1} is running")
running(i) = false
count -= 1
safe = true
for (j <- 0 until resources) {
available(j) += currentlyAllocated(i)(j)
}
}
}
if (!safe) {
println("The processes are in an unsafe state.")
return
}
println(s"The processes are in a safe state.\nAvailable resources: ${available.mkString(", ")}\n")
}
}
}
</syntaxhighlight>
'''input'''
<pre>
4
3
6 5 7 6
1 2 2 1
1 0 3 3
1 2 1 0
3 3 2 2
1 2 3 4
1 3 5 0
</pre>
{{out}}
<pre>
Number of resources: 4
Number of processes: 3
Maximum resources: 6 5 7 6
-- resources allocated for each process --
process 1: 1 2 2 1
process 2: 1 0 3 3
process 3: 1 2 1 0
--- maximum resources for each process ---
process 1: 3 3 2 2
process 2: 1 2 3 4
process 3: 1 3 5 0
Total resources allocated: 3, 4, 6, 4
Total resources available: 3, 1, 1, 2
process 1 is running
process 2 is running
process 3 is running
The processes are in a safe state.
Available resources: 6, 5, 7, 6
</pre>
=={{header|Swift}}==
<syntaxhighlight lang="swift">import Foundation
print("Enter the number of resources: ", terminator: "")
guard let resources = Int(readLine(strippingNewline: true)!) else {
fatalError()
}
print("Enter the number of processes: ", terminator: "")
guard let processes = Int(readLine(strippingNewline: true)!) else {
fatalError()
}
var running = Array(repeating: true, count: processes)
var curr = Array(repeating: [Int](), count: processes)
var alloc = Array(repeating: 0, count: resources)
var available = Array(repeating: 0, count: resources)
var maxClaims = Array(repeating: [Int](), count: processes)
var count = processes
print("Enter the \(resources)-item claim vector: ", terminator: "")
guard let maxRes = readLine(strippingNewline: true)?.components(separatedBy: " ").compactMap(Int.init),
maxRes.count == resources else {
fatalError()
}
print("Enter the \(processes)-line \(resources)-column allocated-resource table:")
for i in 0..<processes {
print("Row \(i + 1): ", terminator: "")
guard let allc = readLine(strippingNewline: true)?.components(separatedBy: " ").compactMap(Int.init),
maxRes.count == resources else {
fatalError()
}
curr[i] = allc
}
print("Enter the \(processes)-line \(resources)-column maximum-claim table:")
for i in 0..<processes {
print("Row \(i + 1): ", terminator: "")
guard let clms = readLine(strippingNewline: true)?.components(separatedBy: " ").compactMap(Int.init),
maxRes.count == resources else {
fatalError()
}
maxClaims[i] = clms
}
for i in 0..<processes {
for j in 0..<resources {
alloc[j] += curr[i][j]
}
}
for i in 0..<resources {
available[i] = maxRes[i] - alloc[i]
}
print("The claim vector is: \(maxRes)")
print("The allocated resources table is: \(curr)")
print("The maximum claims table is: \(maxClaims)")
print("The allocated resources are: \(alloc)")
print("The available resources are: \(available)")
while count != 0 {
var safe = false
for i in 0..<processes where running[i] {
var exec = true
for j in 0..<resources where maxClaims[i][j] - curr[i][j] > available[j] {
exec = false
break
}
if exec {
print("Process \(i + 1) is executing.")
running[i] = false
count -= 1
safe = true
for j in 0..<resources {
available[j] += curr[i][j]
}
break
}
}
if safe {
print("The process is in safe state.")
} else {
print("The processes are in unsafe state.")
break
}
print("The available vector is: \(available)")
}</syntaxhighlight>
{{out|Input and Output}}
<pre style="scroll=overflow; height: 20em">Enter the number of resources: 4
Enter the number of processes: 5
Enter the 4-item claim vector: 8 5 9 7
Enter the 5-line 4-column allocated-resource table:
Row 1: 2 0 1 1
Row 2: 0 1 2 1
Row 3: 4 0 0 3
Row 4: 0 2 1 0
Row 5: 1 0 3 0
Enter the 5-line 4-column maximum-claim table:
Row 1: 3 2 1 4
Row 2: 0 2 5 2
Row 3: 5 1 0 5
Row 4: 1 5 3 0
Row 5: 3 0 3 3
The claim vector is: [8, 5, 9, 7]
The allocated resources table is: [[2, 0, 1, 1], [0, 1, 2, 1], [4, 0, 0, 3], [0, 2, 1, 0], [1, 0, 3, 0]]
The maximum claims table is: [[3, 2, 1, 4], [0, 2, 5, 2], [5, 1, 0, 5], [1, 5, 3, 0], [3, 0, 3, 3]]
The allocated resources are: [7, 3, 7, 5]
The available resources are: [1, 2, 2, 2]
Process 3 is executing.
The process is in safe state.
The available vector is: [5, 2, 2, 5]
Process 1 is executing.
The process is in safe state.
The available vector is: [7, 2, 3, 6]
Process 2 is executing.
The process is in safe state.
The available vector is: [7, 3, 5, 7]
Process 4 is executing.
The process is in safe state.
The available vector is: [7, 5, 6, 7]
Process 5 is executing.
The process is in safe state.
The available vector is: [8, 5, 9, 7]</pre>
=={{header|Wren}}==
{{trans|Kotlin}}
<syntaxhighlight lang="wren">import "io" for Stdin, Stdout
System.write("Enter the number of resources: ")
Stdout.flush()
var r = Num.fromString(Stdin.readLine())
System.write("\nEnter the number of processes: ")
Stdout.flush()
var p = Num.fromString(Stdin.readLine())
System.write("\nEnter Claim Vector: ")
Stdout.flush()
var maxRes = Stdin.readLine().split(" ").map { |s| Num.fromString(s) }.toList
System.print("\nEnter Allocated Resource Table:")
var curr = List.filled(p, null)
for (i in 0...p) {
System.write("Row %(i + 1): ")
Stdout.flush()
curr[i] = Stdin.readLine().split(" ").map { |s| Num.fromString(s) }.toList
}
System.print("\nEnter Maximum Claim Table: ")
var maxClaim = List.filled(p, null)
for (i in 0...p) {
System.write("Row %(i + 1): ")
Stdout.flush()
maxClaim[i] = Stdin.readLine().split(" ").map { |s| Num.fromString(s) }.toList
}
var alloc = List.filled(r, 0)
for (i in 0...p) {
for (j in 0...r) alloc[j] = alloc[j] + curr[i][j]
}
System.print("\nAllocated Resources: %(alloc.join(" "))")
var avl = List.filled(r, 0)
for (i in 0...r) avl[i] = maxRes[i] - alloc[i]
System.print("\nAvailable Resources: %(avl.join(" "))")
var running = List.filled(p, true)
var count = p
while (count != 0) {
var safe = false
for (i in 0...p) {
if (running[i]) {
var exec = true
for (j in 0...r) {
if (maxClaim[i][j] - curr[i][j] > avl[j]) {
exec = false
break
}
}
if (exec) {
System.print("\nProcess %(i + 1) is executing.")
running[i] = false
count = count - 1
safe = true
for (j in 0...r) avl[j] = avl[j] + curr[i][j]
break
}
}
}
if (!safe) {
System.print("\nThe processes are in an unsafe state.")
break
}
System.write("\nThe process is in a safe state.")
System.print("\nAvailable Vector: %(avl.join(" "))")
}</syntaxhighlight>
{{out}}
Sample input/output:
<pre>
Enter the number of resources: 4
Enter the number of processes: 5
Enter Claim Vector: 8 5 9 7
Enter Allocated Resource Table:
Row 1: 2 0 1 1
Row 2: 0 1 2 1
Row 3: 4 0 0 3
Row 4: 0 2 1 0
Row 5: 1 0 3 0
Enter Maximum Claim Table:
Row 1: 3 2 1 4
Row 2: 0 2 5 2
Row 3: 5 1 0 5
Row 4: 1 5 3 0
Row 5: 3 0 3 3
Allocated Resources: 7 3 7 5
Available Resources: 1 2 2 2
Process 3 is executing.
The process is in a safe state.
Available Vector: 5 2 2 5
Process 1 is executing.
The process is in a safe state.
Available Vector: 7 2 3 6
Process 2 is executing.
The process is in a safe state.
Available Vector: 7 3 5 7
Process 4 is executing.
The process is in a safe state.
Available Vector: 7 5 6 7
Process 5 is executing.
The process is in a safe state.
Available Vector: 8 5 9 7
</pre>
=={{header|Yabasic}}==
{{trans|FreeBASIC}}
{{todo|Python|Translate all Spanish texts to English}}
<syntaxhighlight lang="yabasic">
clear screen
input "Ingrese la cantidad de recursos: " r
input "Ingrese la cantidad de procesos: " p
print "\nIngrese los recursos m ximos: "
dim maxRes(r)
for i = 1 to r
input " " maxRes(i)
next i
print "\n-- recursos asignados para cada proceso --"
dim curr(p, r)
for i = 1 to p
print "proceso ", i, ":"
for j = 1 to r
input " " curr(i, j)
next j
print
next i
print "\n--- recursos m ximos para cada proceso ---"
dim maxReclam(p, r)
for i = 1 to p
print "proceso ", i, ":"
for j = 1 to r
input " " maxReclam(i, j)
next j
print
next i
print "\nRecursos totales asignados : ";
dim recAsigad(r)
for i = 1 to p
for j = 1 to r
recAsigad(j) = recAsigad(j) + curr(i, j)
next j
next i
for i = 1 to r
print recAsigad(i), " ";
next i
dim recDispon(r)
print "\nRecursos totales disponibles: ";
for i = 1 to r
recDispon(i) = maxRes(i) - recAsigad(i)
print recDispon(i), " ";
next i
dim ejecutando(p)
for i = 1 to p
ejecutando(i) = True
next i
contar = p
while contar <> 0
seguro = False
for i = 1 to p
if ejecutando(i) then
ejecuta = True
for j = 1 to r
if (maxReclam(i,j) - curr(i,j) > recDispon(j)) then
ejecuta = False
break
end if
next j
if ejecuta then
print color("cya") "\n\nproceso ", i, " ejecut ndose."
ejecutando(i) = False
contar = contar - 1
seguro = True
for j = 0 to r
recDispon(j) = recDispon(j) + curr(i,j)
next j
break
end if
end if
next i
if not seguro then
print color("red") "\nLos procesos est n en un estado inseguro."
break
end if
print color("gre") "El proceso est en un estado seguro."
print color("whi")"Recursos disponibles: ",
for i = 1 to r
print recDispon(i), " ";
next i
wend
print
end
</syntaxhighlight>
Line 337 ⟶ 2,296:
{{omit from|GUISS}}
{{omit from|Openscad}}
{{omit from|TPP}}
| |||