QuizGenerator 0.4.4__py3-none-any.whl → 0.5.1__py3-none-any.whl

QuizGenerator/premade_questions/cst334/process.py

@@ -7,9 +7,7 @@ import dataclasses
 import enum
 import io
 import logging
-import math
 import os
-import queue
 import uuid
 from typing import List
 
@@ -65,6 +63,8 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
   TIME_QUANTUM = None
   
   ROUNDING_DIGITS = 2
+  IMAGE_DPI = 140
+  IMAGE_FIGSIZE = (9.5, 5.5)
   
   @dataclasses.dataclass
   class Job:
@@ -368,18 +368,28 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
     self.answers.update({
       "answer__average_response_time": Answer.auto_float(
         "answer__average_response_time",
-        sum([job.response_time for job in jobs]) / len(jobs)
+        sum([job.response_time for job in jobs]) / len(jobs),
+        label="Overall average response time"
       ),
       "answer__average_turnaround_time": Answer.auto_float(
         "answer__average_turnaround_time",
-        sum([job.turnaround_time for job in jobs]) / len(jobs)
+        sum([job.turnaround_time for job in jobs]) / len(jobs),
+        label="Overall average TAT"
       )
     })
 
     # Return whether this workload is interesting
     return self.is_interesting()
   
-  def get_body(self, *args, **kwargs) -> ContentAST.Section:
+  def _get_body(self, *args, **kwargs):
+    """
+    Build question body and collect answers.
+    Returns:
+        Tuple of (body_ast, answers_list)
+    """
+    from typing import List
+    answers: List[Answer] = []
+
     # Create table data for scheduling results
     table_rows = []
     for job_id in sorted(self.job_stats.keys()):
@@ -390,6 +400,9 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
         "Response Time": f"answer__response_time_job{job_id}",  # Answer key
         "TAT": f"answer__turnaround_time_job{job_id}"  # Answer key
       })
+      # Collect answers for this job
+      answers.append(self.answers[f"answer__response_time_job{job_id}"])
+      answers.append(self.answers[f"answer__turnaround_time_job{job_id}"])
 
     # Create table using mixin
     scheduling_table = self.create_answer_table(
@@ -398,15 +411,18 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
       answer_columns=["Response Time", "TAT"]
     )
 
+    # Collect average answers
+    avg_response_answer = self.answers["answer__average_response_time"]
+    avg_tat_answer = self.answers["answer__average_turnaround_time"]
+    answers.append(avg_response_answer)
+    answers.append(avg_tat_answer)
+
     # Create average answer block
-    average_block = ContentAST.AnswerBlock([
-      ContentAST.Answer(self.answers["answer__average_response_time"], label="Overall average response time"),
-      ContentAST.Answer(self.answers["answer__average_turnaround_time"], label="Overall average TAT")
-    ])
+    average_block = ContentAST.AnswerBlock([avg_response_answer, avg_tat_answer])
 
     # Use mixin to create complete body
     intro_text = (
-      f"Given the below information, compute the required values if using <b>{self.scheduler_algorithm}</b> scheduling. "
+      f"Given the below information, compute the required values if using **{self.scheduler_algorithm}** scheduling. "
       f"Break any ties using the job number."
     )
 
@@ -418,18 +434,28 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
 
     body = self.create_fill_in_table_body(intro_text, instructions, scheduling_table)
     body.add_element(average_block)
+    return body, answers
+
+  def get_body(self, *args, **kwargs) -> ContentAST.Section:
+    """Build question body (backward compatible interface)."""
+    body, _ = self._get_body(*args, **kwargs)
     return body
   
-  def get_explanation(self, **kwargs) -> ContentAST.Section:
+  def _get_explanation(self, **kwargs):
+    """
+    Build question explanation.
+    Returns:
+        Tuple of (explanation_ast, answers_list)
+    """
     explanation = ContentAST.Section()
-    
+
     explanation.add_element(
       ContentAST.Paragraph([
         f"To calculate the overall Turnaround and Response times using {self.scheduler_algorithm} "
         f"we want to first start by calculating the respective target and response times of all of our individual jobs."
       ])
     )
-    
+
     explanation.add_elements([
       ContentAST.Paragraph([
         "We do this by subtracting arrival time from either the completion time or the start time.  That is:"
@@ -437,13 +463,13 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
       ContentAST.Equation("Job_{TAT} = Job_{completion} - Job_{arrival\_time}"),
       ContentAST.Equation("Job_{response} = Job_{start} - Job_{arrival\_time}"),
     ])
-    
+
     explanation.add_element(
       ContentAST.Paragraph([
         f"For each of our {len(self.job_stats.keys())} jobs, we can make these calculations.",
       ])
     )
-    
+
     ## Add in TAT
     explanation.add_element(
       ContentAST.Paragraph([
@@ -456,7 +482,7 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
         for job_id in sorted(self.job_stats.keys())
       ])
     )
-    
+
     summation_line = ' + '.join([
       f"{self.job_stats[job_id]['TAT']:0.{self.ROUNDING_DIGITS}f}" for job_id in sorted(self.job_stats.keys())
     ])
@@ -467,8 +493,8 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
         f"= {self.overall_stats['TAT']:0.{self.ROUNDING_DIGITS}f}",
       ])
     )
-    
-    
+
+
     ## Add in Response
     explanation.add_element(
       ContentAST.Paragraph([
@@ -481,7 +507,7 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
       for job_id in sorted(self.job_stats.keys())
     ])
     )
-    
+
     summation_line = ' + '.join([
       f"{self.job_stats[job_id]['Response']:0.{self.ROUNDING_DIGITS}f}" for job_id in sorted(self.job_stats.keys())
     ])
@@ -494,7 +520,7 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
         "\n",
       ])
     )
-    
+
     explanation.add_element(
       ContentAST.Table(
         headers=["Time", "Events"],
@@ -504,14 +530,19 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
         ]
       )
     )
-    
+
     explanation.add_element(
       ContentAST.Picture(
         img_data=self.make_image(),
         caption="Process Scheduling Overview"
       )
     )
-    
+
+    return explanation, []
+
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    """Build question explanation (backward compatible interface)."""
+    explanation, _ = self._get_explanation(**kwargs)
     return explanation
   
   def is_interesting(self) -> bool:
@@ -521,7 +552,7 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
   
   def make_image(self):
     
-    fig, ax = plt.subplots(1, 1)
+    fig, ax = plt.subplots(1, 1, figsize=self.IMAGE_FIGSIZE, dpi=self.IMAGE_DPI)
     
     for x_loc in set([t for job_id in self.job_stats.keys() for t in self.job_stats[job_id]["state_changes"] ]):
       ax.axvline(x_loc, zorder=0)
@@ -579,7 +610,8 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
     
     # Save to BytesIO object instead of a file
     buffer = io.BytesIO()
-    plt.savefig(buffer, format='png')
+    plt.tight_layout()
+    plt.savefig(buffer, format='png', dpi=self.IMAGE_DPI, bbox_inches='tight', pad_inches=0.2)
     plt.close(fig)
     
     # Reset buffer position to the beginning
@@ -599,50 +631,508 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
     return image_path
     
 
-class MLFQ_Question(ProcessQuestion):
-  
-  MIN_DURATION = 10
-  MAX_DURATION = 100
+@QuestionRegistry.register()
+class MLFQQuestion(ProcessQuestion, TableQuestionMixin, BodyTemplatesMixin):
+  MIN_DURATION = 4
+  MAX_DURATION = 12
   MIN_ARRIVAL = 0
-  MAX_ARRIVAL = 100
-  
+  MAX_ARRIVAL = 10
+  DEFAULT_NUM_JOBS = 3
+  DEFAULT_NUM_QUEUES = 3
+  ROUNDING_DIGITS = 2
+  IMAGE_DPI = 140
+  IMAGE_FIGSIZE = (9.5, 6.5)
+
   @dataclasses.dataclass
-  class Job():
-    arrival_time: float
-    duration: float
-    elapsed_time: float = 0.0
-    response_time: float = None
-    turnaround_time: float = None
-    
-    def run_for_slice(self, slice_duration):
-      self.elapsed_time += slice_duration
-    
-    def is_complete(self):
-      return math.isclose(self.duration, self.elapsed_time)
-  
+  class Job:
+    job_id: int
+    arrival_time: int
+    duration: int
+    remaining_time: int
+    queue_level: int = 0
+    time_in_queue: int = 0
+    response_time: float | None = None
+    turnaround_time: float | None = None
+    remaining_quantum: int | None = None
+    run_intervals: List[tuple] = dataclasses.field(default_factory=list)
+    max_queue_level: int = 0
+
+  def __init__(
+    self,
+    num_jobs: int = DEFAULT_NUM_JOBS,
+    num_queues: int = DEFAULT_NUM_QUEUES,
+    min_job_length: int = MIN_DURATION,
+    max_job_length: int = MAX_DURATION,
+    boost_interval: int | None = None,
+    boost_interval_range: List[int] | None = None,
+    *args,
+    **kwargs
+  ):
+    kwargs["num_jobs"] = num_jobs
+    kwargs["num_queues"] = num_queues
+    kwargs["min_job_length"] = min_job_length
+    kwargs["max_job_length"] = max_job_length
+    if boost_interval is not None:
+      kwargs["boost_interval"] = boost_interval
+    if boost_interval_range is not None:
+      kwargs["boost_interval_range"] = boost_interval_range
+    super().__init__(*args, **kwargs)
+    self.num_jobs = num_jobs
+    self.num_queues = num_queues
+    self.min_job_length = min_job_length
+    self.max_job_length = max_job_length
+    self.boost_interval = boost_interval
+    self.boost_interval_range = boost_interval_range
+
+  def get_workload(self, num_jobs: int) -> List[MLFQQuestion.Job]:
+    arrivals = [0]
+    if num_jobs > 1:
+      arrivals.extend(
+        self.rng.randint(self.MIN_ARRIVAL, self.MAX_ARRIVAL)
+        for _ in range(num_jobs - 1)
+      )
+      if max(arrivals) == 0:
+        arrivals[-1] = self.rng.randint(1, self.MAX_ARRIVAL)
+
+    durations = [
+      self.rng.randint(self.min_job_length, self.max_job_length)
+      for _ in range(num_jobs)
+    ]
+
+    jobs = []
+    for i in range(num_jobs):
+      jobs.append(
+        MLFQQuestion.Job(
+          job_id=i,
+          arrival_time=arrivals[i],
+          duration=durations[i],
+          remaining_time=durations[i],
+        )
+      )
+    return jobs
+
+  def _normalize_queue_params(self, values: List[int] | None, num_queues: int) -> List[int]:
+    if values is None:
+      return []
+    values = list(values)
+    while len(values) < num_queues:
+      values.append(values[-1])
+    return values[:num_queues]
+
+  def run_simulation(
+    self,
+    jobs: List[MLFQQuestion.Job],
+    queue_quantums: List[int],
+    queue_allotments: List[int | None],
+    boost_interval: int | None,
+  ) -> None:
+    self.timeline = collections.defaultdict(list)
+    self.boost_times = []
+    pending = sorted(jobs, key=lambda j: (j.arrival_time, j.job_id))
+    queues = [collections.deque() for _ in range(len(queue_quantums))]
+    completed = set()
+
+    curr_time = pending[0].arrival_time if pending else 0
+    self.timeline[curr_time].append("Simulation Start")
+    next_boost_time = None
+    if boost_interval is not None:
+      next_boost_time = boost_interval
+
+    def enqueue_arrivals(up_to_time: int) -> None:
+      nonlocal pending
+      while pending and pending[0].arrival_time <= up_to_time:
+        job = pending.pop(0)
+        job.queue_level = len(queues) - 1
+        job.time_in_queue = 0
+        job.remaining_quantum = None
+        queues[-1].append(job)
+        self.timeline[job.arrival_time].append(
+          f"Job{job.job_id} arrived (dur = {job.duration})"
+        )
+
+    def apply_boost(curr_time: int, running_job: MLFQQuestion.Job | None = None) -> None:
+      jobs_to_boost = []
+      for q in queues:
+        while q:
+          jobs_to_boost.append(q.popleft())
+      if running_job is not None and running_job.remaining_time > 0:
+        jobs_to_boost.append(running_job)
+      if not jobs_to_boost:
+        self.boost_times.append(curr_time)
+        return
+      for job in sorted(jobs_to_boost, key=lambda j: j.job_id):
+        job.queue_level = len(queues) - 1
+        job.time_in_queue = 0
+        job.remaining_quantum = None
+        queues[-1].append(job)
+      self.timeline[curr_time].append(
+        f"Boosted all jobs to Q{len(queues) - 1}"
+      )
+      self.boost_times.append(curr_time)
+
+    enqueue_arrivals(curr_time)
+
+    while len(completed) < len(jobs):
+      q_idx = next(
+        (i for i in range(len(queues) - 1, -1, -1) if queues[i]),
+        None
+      )
+      if q_idx is None:
+        next_times = []
+        if pending:
+          next_times.append(pending[0].arrival_time)
+        if next_boost_time is not None:
+          next_times.append(next_boost_time)
+        if next_times:
+          next_time = min(next_times)
+          if next_time > curr_time:
+            self.timeline[curr_time].append("CPU idle")
+          curr_time = next_time
+          enqueue_arrivals(curr_time)
+          while next_boost_time is not None and curr_time >= next_boost_time:
+            apply_boost(curr_time)
+            next_boost_time += boost_interval
+          continue
+        break
+
+      job = queues[q_idx].popleft()
+      quantum = queue_quantums[q_idx]
+      if job.remaining_quantum is None or job.remaining_quantum <= 0:
+        job.remaining_quantum = quantum
+
+      slice_duration = min(job.remaining_quantum, job.remaining_time)
+      preempted = False
+      if q_idx < len(queues) - 1 and pending:
+        next_arrival = pending[0].arrival_time
+        if next_arrival < curr_time + slice_duration:
+          slice_duration = next_arrival - curr_time
+          preempted = True
+      if next_boost_time is not None and next_boost_time < curr_time + slice_duration:
+        slice_duration = next_boost_time - curr_time
+        preempted = True
+
+      if job.response_time is None:
+        job.response_time = curr_time - job.arrival_time
+
+      if slice_duration > 0:
+        self.timeline[curr_time].append(
+          f"Running Job{job.job_id} in Q{q_idx} for {slice_duration}"
+        )
+        job.run_intervals.append((curr_time, curr_time + slice_duration, q_idx))
+        curr_time += slice_duration
+        job.remaining_time -= slice_duration
+        job.time_in_queue += slice_duration
+        job.remaining_quantum -= slice_duration
+
+      enqueue_arrivals(curr_time)
+      boosted_current_job = False
+      while next_boost_time is not None and curr_time >= next_boost_time:
+        apply_boost(curr_time, running_job=job if not boosted_current_job else None)
+        boosted_current_job = True
+        next_boost_time += boost_interval
+
+      if job.remaining_time <= 0:
+        job.turnaround_time = curr_time - job.arrival_time
+        job.remaining_quantum = None
+        completed.add(job.job_id)
+        self.timeline[curr_time].append(
+          f"Completed Job{job.job_id} (TAT = {job.turnaround_time})"
+        )
+        continue
+      if boosted_current_job:
+        continue
+
+      allotment = queue_allotments[q_idx]
+      if (
+        allotment is not None
+        and job.time_in_queue >= allotment
+        and q_idx > 0
+      ):
+        job.queue_level = q_idx - 1
+        job.max_queue_level = max(job.max_queue_level, job.queue_level)
+        job.time_in_queue = 0
+        job.remaining_quantum = None
+        queues[q_idx - 1].append(job)
+        self.timeline[curr_time].append(
+          f"Demoted Job{job.job_id} to Q{q_idx - 1}"
+        )
+        continue
+
+      if preempted and job.remaining_quantum > 0:
+        queues[q_idx].appendleft(job)
+      else:
+        if job.remaining_quantum <= 0:
+          job.remaining_quantum = None
+        queues[q_idx].append(job)
+
   def refresh(self, *args, **kwargs):
     super().refresh(*args, **kwargs)
-    
-    # Set up defaults
-    # todo: allow for per-queue specification of durations, likely through dicts
-    num_queues = kwargs.get("num_queues", 2)
-    num_jobs = kwargs.get("num_jobs", 2)
-    
-    # Set up queues that we will be using
-    mlfq_queues = {
-      priority : queue.Queue()
-      for priority in range(num_queues)
+
+    self.num_jobs = kwargs.get("num_jobs", self.num_jobs)
+    self.num_queues = kwargs.get("num_queues", self.num_queues)
+    self.min_job_length = kwargs.get("min_job_length", self.min_job_length)
+    self.max_job_length = kwargs.get("max_job_length", self.max_job_length)
+    self.boost_interval = kwargs.get("boost_interval", self.boost_interval)
+    self.boost_interval_range = kwargs.get(
+      "boost_interval_range",
+      self.boost_interval_range
+    )
+    if self.boost_interval is None and self.boost_interval_range:
+      low, high = self.boost_interval_range
+      self.boost_interval = self.rng.randint(low, high)
+
+    jobs = self.get_workload(self.num_jobs)
+
+    queue_quantums = [2**(self.num_queues - 1 - i) for i in range(self.num_queues)]
+    queue_quantums = self._normalize_queue_params(queue_quantums, self.num_queues)
+    queue_quantums = [int(q) for q in queue_quantums]
+
+    queue_allotments = [None] + [
+      queue_quantums[i] * 2 for i in range(1, self.num_queues)
+    ]
+    queue_allotments = self._normalize_queue_params(queue_allotments, self.num_queues)
+    queue_allotments = [
+      int(allotment) if allotment is not None else None
+      for allotment in queue_allotments
+    ]
+    queue_allotments[0] = None
+
+    self.queue_quantums = queue_quantums
+    self.queue_allotments = queue_allotments
+
+    self.run_simulation(jobs, queue_quantums, queue_allotments, self.boost_interval)
+
+    self.job_stats = {
+      job.job_id: {
+        "arrival_time": job.arrival_time,
+        "duration": job.duration,
+        "Response": job.response_time,
+        "TAT": job.turnaround_time,
+        "run_intervals": list(job.run_intervals),
+      }
+      for job in jobs
     }
-    
-    # Set up jobs that we'll be using
-    jobs = [
-      MLFQ_Question.Job(
-        arrival_time=self.rng.randint(self.MIN_ARRIVAL, self.MAX_ARRIVAL),
-        duration=self.rng.randint(self.MIN_DURATION, self.MAX_DURATION),
-        
+
+    for job_id in sorted(self.job_stats.keys()):
+      self.answers.update({
+        f"answer__turnaround_time_job{job_id}": Answer.auto_float(
+          f"answer__turnaround_time_job{job_id}",
+          self.job_stats[job_id]["TAT"]
+        )
+      })
+
+    return self.is_interesting()
+
+  def _get_body(self, *args, **kwargs):
+    answers: List[Answer] = []
+
+    queue_rows = []
+    for i in reversed(range(self.num_queues)):
+      allotment = self.queue_allotments[i]
+      queue_rows.append([
+        f"Q{i}",
+        self.queue_quantums[i],
+        "infinite" if allotment is None else allotment
+      ])
+    queue_table = ContentAST.Table(
+      headers=["Queue", "Quantum", "Allotment"],
+      data=queue_rows
+    )
+
+    table_rows = []
+    for job_id in sorted(self.job_stats.keys()):
+      table_rows.append({
+        "Job ID": f"Job{job_id}",
+        "Arrival": self.job_stats[job_id]["arrival_time"],
+        "Duration": self.job_stats[job_id]["duration"],
+        "TAT": f"answer__turnaround_time_job{job_id}",
+      })
+      answers.append(self.answers[f"answer__turnaround_time_job{job_id}"])
+
+    scheduling_table = self.create_answer_table(
+      headers=["Job ID", "Arrival", "Duration", "TAT"],
+      data_rows=table_rows,
+      answer_columns=["TAT"]
+    )
+
+    intro_text = (
+      "Assume an MLFQ scheduler with round-robin inside each queue. "
+      f"New jobs enter the highest-priority queue (Q{self.num_queues - 1}) "
+      "and a job is demoted after using its total allotment for that queue. "
+      "If a higher-priority job arrives, it preempts any lower-priority job."
+    )
+
+    instructions = (
+      f"Compute the turnaround time (TAT) for each job. "
+      f"Round to at most {Answer.DEFAULT_ROUNDING_DIGITS} digits after the decimal."
+    )
+
+    body = ContentAST.Section()
+    body.add_element(ContentAST.Paragraph([intro_text]))
+    body.add_element(queue_table)
+    if self.boost_interval is not None:
+      body.add_element(ContentAST.Paragraph([
+        f"Every {self.boost_interval} time units, all jobs are boosted to "
+        f"Q{self.num_queues - 1}. After a boost, scheduling restarts with the "
+        "lowest job number in that queue."
+      ]))
+    body.add_element(ContentAST.Paragraph([instructions]))
+    body.add_element(scheduling_table)
+    return body, answers
+
+  def get_body(self, *args, **kwargs) -> ContentAST.Section:
+    body, _ = self._get_body(*args, **kwargs)
+    return body
+
+  def _get_explanation(self, **kwargs):
+    explanation = ContentAST.Section()
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "Turnaround time (TAT) is the completion time minus the arrival time.",
+        "We calculate it for each job after simulating the schedule."
+      ])
+    )
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "For each job:"
+      ] + [
+        f"Job{job_id}_TAT = "
+        f"{self.job_stats[job_id]['arrival_time'] + self.job_stats[job_id]['TAT']:0.{self.ROUNDING_DIGITS}f} "
+        f"- {self.job_stats[job_id]['arrival_time']:0.{self.ROUNDING_DIGITS}f} "
+        f"= {self.job_stats[job_id]['TAT']:0.{self.ROUNDING_DIGITS}f}"
+        for job_id in sorted(self.job_stats.keys())
+      ])
+    )
+
+    explanation.add_element(
+      ContentAST.Table(
+        headers=["Time", "Events"],
+        data=[
+          [f"{t:0.{self.ROUNDING_DIGITS}f}s"] + ['\n'.join(events)]
+          for t in sorted(self.timeline.keys())
+          if (events := [
+            event for event in self.timeline[t]
+            if (
+              "arrived" in event
+              or "Demoted" in event
+              or "Boosted" in event
+              or "Completed" in event
+              or "Simulation Start" in event
+              or "CPU idle" in event
+            )
+          ])
+        ]
       )
+    )
+
+    explanation.add_element(
+      ContentAST.Picture(
+        img_data=self.make_image(),
+        caption="MLFQ Scheduling Overview"
+      )
+    )
+
+    return explanation, []
+
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    explanation, _ = self._get_explanation(**kwargs)
+    return explanation
+
+  def make_image(self):
+    fig, ax = plt.subplots(1, 1, figsize=self.IMAGE_FIGSIZE, dpi=self.IMAGE_DPI)
+
+    num_jobs = len(self.job_stats)
+    if num_jobs == 0:
+      buffer = io.BytesIO()
+      plt.tight_layout()
+      plt.savefig(buffer, format='png', dpi=self.IMAGE_DPI, bbox_inches='tight')
+      plt.close(fig)
+      buffer.seek(0)
+      return buffer
+
+    job_colors = {
+      job_id: str(0.15 + 0.7 * (idx / max(1, num_jobs - 1)))
+      for idx, job_id in enumerate(sorted(self.job_stats.keys()))
+    }
+    job_lane = {
+      job_id: idx
+      for idx, job_id in enumerate(sorted(self.job_stats.keys(), reverse=True))
+    }
+    lanes_per_queue = num_jobs
+
+    for job_id in sorted(self.job_stats.keys()):
+      for start, stop, queue_level in self.job_stats[job_id]["run_intervals"]:
+        y_loc = queue_level * lanes_per_queue + job_lane[job_id]
+        ax.barh(
+          y=[y_loc],
+          left=[start],
+          width=[stop - start],
+          edgecolor='black',
+          linewidth=1.5,
+          color=job_colors[job_id]
+        )
+
+    for queue_idx in range(self.num_queues):
+      if queue_idx % 2 == 1:
+        ax.axhspan(
+          queue_idx * lanes_per_queue - 0.5,
+          (queue_idx + 1) * lanes_per_queue - 0.5,
+          facecolor='0.97',
+          edgecolor='none',
+          zorder=-1
+        )
+
+    arrival_times = sorted({
+      self.job_stats[job_id]["arrival_time"]
+      for job_id in self.job_stats.keys()
+    })
+    bottom_label_y = -0.1
+    for arrival_time in arrival_times:
+      ax.axvline(arrival_time, color='0.2', linestyle=':', linewidth=1.2, zorder=0)
+      ax.text(
+        arrival_time + 0.2,
+        bottom_label_y,
+        f"{arrival_time:0.{self.ROUNDING_DIGITS}f}s",
+        color='0.2',
+        rotation=90,
+        ha='left',
+        va='bottom'
+      )
+
+    completion_times = sorted({
+      self.job_stats[job_id]["arrival_time"] + self.job_stats[job_id]["TAT"]
+      for job_id in self.job_stats.keys()
+    })
+    for completion_time in completion_times:
+      ax.axvline(completion_time, color='red', linewidth=1.5, zorder=0)
+      ax.text(
+        completion_time - 0.6,
+        self.num_queues * lanes_per_queue - 0.5,
+        f"{completion_time:0.{self.ROUNDING_DIGITS}f}s",
+        color='red',
+        rotation=90,
+        ha='center',
+        va='top'
+      )
+
+    for boost_time in sorted(set(self.boost_times)):
+      ax.axvline(boost_time, color='tab:blue', linestyle='--', linewidth=1.2, zorder=0)
+
+    tick_positions = [
+      q * lanes_per_queue + (lanes_per_queue - 1) / 2
+      for q in range(self.num_queues)
     ]
-    
-    curr_time = -1.0
-    while True:
-      pass
+    ax.set_yticks(tick_positions)
+    ax.set_yticklabels([f"Q{i}" for i in range(self.num_queues)])
+    ax.set_ylim(-0.5, self.num_queues * lanes_per_queue - 0.5)
+    ax.set_xlim(xmin=0)
+    ax.set_xlabel("Time")
+
+    buffer = io.BytesIO()
+    plt.tight_layout()
+    plt.savefig(buffer, format='png', dpi=self.IMAGE_DPI, bbox_inches='tight')
+    plt.close(fig)
+    buffer.seek(0)
+    return buffer