added process scheduling algorithms

process-scheduling/utils.typ

@@ -0,0 +1,155 @@
+#import "@preview/cetz:0.3.1": canvas, draw
+
+
+#let UNBORN = 0
+#let READY = 1
+#let RUNNING = 2
+#let TERMINATED = 3
+
+#let colors = (
+  none,
+  gray,
+  green,
+  blue.lighten(50%)
+)
+
+#let task(pid, arrival, duration, priority) = {
+  return ((
+    pid: pid,
+    arrival: arrival,
+    duration: duration,
+    remaining: duration,
+    priority: priority
+  ),)
+}
+
+#let display-processes(width: auto, display-durations: none, display-priorities: false, ..args) = layout(size => {
+  let processes = args.pos()
+  processes = processes.map(p => if type(p) == dictionary {p} else {(
+    pid: p.first(),
+    priority: if display-priorities {p.at(1)} else {0},
+    events: p.slice(if display-priorities {2} else {1})
+  )})
+  let max-t = calc.max(
+    ..processes.map(
+      p => calc.max(
+        ..p.events.map(
+          e => e.last()
+        )
+      )
+    )
+  )
+
+  let display-durations = if display-durations == none {
+    ()
+  } else if type(display-durations) == array {
+    display-durations
+  } else {
+    (display-durations,)
+  }
+
+  let shapes = ()
+  let width = width
+  if (width == auto) {
+    width = size.width
+  }
+  let y = 0
+  for proc in processes {
+    proc.events.push((TERMINATED, max-t))
+    shapes += draw.content(
+      (0, y - .25),
+      str(proc.pid),
+      anchor: "east",
+      padding: 5pt
+    )
+    
+    for i in range(proc.events.len() - 1) {
+      let (state1, t1) = proc.events.at(i)
+      let (state2, t2) = proc.events.at(i+1)
+      let x1 = t1 / max-t * width
+      let x2 = t2 / max-t * width
+      let y1 = y
+      let y2 = y - .5
+      if (state1 == TERMINATED) {
+        y1 = y - .2
+        y2 = y - .3
+      }
+      
+      shapes += draw.rect(
+        (x1, y1),
+        (x2, y2),
+        fill: colors.at(state1)
+      )
+
+      if i == 0 and display-priorities {
+        shapes += draw.content(
+          ((x1 + x2) / 2, (y1 + y2) / 2),
+          strong(str(proc.priority)),
+          anchor: "center"
+        )
+      }
+      if state1 in display-durations {
+        shapes += draw.content(
+          ((x1 + x2) / 2, (y1 + y2) / 2),
+          strong(str(t2 - t1)),
+          anchor: "center"
+        )
+      }
+
+      if state1 == RUNNING and state2 == READY {
+        shapes += draw.on-layer(1, draw.circle(
+          (x2, (y1 + y2)/2),
+          radius: .1,
+          fill: red
+        ))
+      }
+    }
+    y -= 0.5
+  }
+
+  let step = calc.pow(
+    10,
+    calc.max(
+      0,
+      calc.floor(
+        calc.log(
+          base: 10,
+          max-t
+        ) - 1
+      )
+    )
+  )
+  let n-steps = calc.floor(max-t / step) + 1
+  for i in range(n-steps) {
+    let t = i * step
+    let x = t / max-t * width
+    shapes += draw.line(
+      (x, 0),
+      (x, if calc.rem(i, 2) == 0 {.5} else {.3}),
+      stroke: black
+    )
+    shapes += draw.on-layer(-1, draw.line(
+      (x, 0),
+      (x, -processes.len() * .5),
+      stroke: (
+        dash: (6pt, 4pt),
+        thickness: 1pt,
+        paint: gray
+      )
+    ))
+    if calc.rem(i, 2) == 0 {
+      shapes += draw.content(
+        (x, .5),
+        str(t),
+        anchor: "south",
+        padding: 5pt
+      )
+    }
+  }
+  shapes += draw.rect(
+    (0, 0),
+    (width, -processes.len() * .5)
+  )
+
+  canvas(shapes)
+})