Imports System.Threading.Thread
 
Public Class ProcessClass
    Private _id As Integer
    Private _arrivalTime As Integer
    Private _ttl As Double
    Private _turnaround As Double
 
    ' process ID
    Public ReadOnly Property ID() As Integer
        Get
            Return _id
        End Get
    End Property
 
    ' This is the time in seconds at which the process is to arrive in the ready list
    Public ReadOnly Property ArrivalTime() As Integer
        Get
            Return _arrivalTime
        End Get
    End Property
 
    ' this is the amount of execution time (in seconds) that the process needs to complete
    Public ReadOnly Property TTL() As Double
        Get
            Return _ttl
        End Get
    End Property
 
    ' this is the amount of time elapsed from when it's first loaded to when it's completely done
    Public ReadOnly Property Turnaround() As Double
        Get
            Return _turnaround
        End Get
    End Property
 
    Public Sub New(ByVal ID As Integer, ByVal ArrivalTime As Integer, ByVal TTL As Single)
        _id = ID
        _arrivalTime = ArrivalTime
        _ttl = TTL
    End Sub
 
    ' simulates execution of the process by decrementing the TTL by the given quantum (in milliseconds) of execution
    Public Sub Update(ByVal Quantum As Integer)
        If _ttl * 1000 < Quantum Then
            Sleep(_ttl * 1000)
            _turnaround += Quantum / 1000
            _ttl = 0
 
        Else
            Sleep(Quantum)
            _turnaround += Quantum / 1000
            _ttl -= Quantum / 1000
 
        End If
    End Sub
End Class

Imports System.IO
Imports System.Threading.Thread
 
Module RRSimulation
 
    Dim ReadyListThread As Threading.Thread
    Dim SchedulerThread As Threading.Thread
 
    ' dispatcher overhead (in milliseconds)
    Dim Overhead As Integer
 
    ' processing time (in milliseconds)
    Dim Quantum As Integer
 
    ' holds the full processlist from the text file
    Dim ProcessList As Generic.Queue(Of ProcessClass)
 
    ' the actual readylist, loaded from the processlist
    Dim ReadyList As Generic.Queue(Of ProcessClass)
 
    ' simulate processes arriving into the readylist
    Public Sub ProcessArrives()
        ' check for more arriving processes
        While ProcessList.Count > 0
 
            ' add new process to ready list
            Dim proc As ProcessClass = ProcessList.Dequeue
            ReadyList.Enqueue(proc)
 
            ' show confirmation
            Console.WriteLine("Process {0} arrives at {1} with execution time {2}", proc.ID, Now.ToLongTimeString, proc.TTL)
 
            ' wait for next process to be ready
            If ProcessList.Peek IsNot Nothing Then Sleep((ProcessList.Peek.ArrivalTime - proc.ArrivalTime) * 1000)
        End While
    End Sub
 
    Public Sub ScheduleReadyProcess()
        While ReadyList.Count > 0
            ' get the next process
            Dim proc As ProcessClass = ReadyList.Dequeue()
            Console.WriteLine("    Executing Process {0} for {1} milliseconds. Current TTL: {2}", proc.ID, Quantum, proc.TTL)
 
            ' run process
            proc.Update(Quantum)
            Console.WriteLine("    Done executing Process {0}. New TTL: {1}", proc.ID, proc.TTL)
 
            ' if not finished, requeue
            If proc.TTL > 0 Then ProcessList.Enqueue(proc)
        End While
    End Sub
 
 
    Sub Main()
 
        ' Initialize
        Overhead = 5
        Quantum = 50
        ProcessList = New Generic.Queue(Of ProcessClass)
        ReadyList = New Generic.Queue(Of ProcessClass)
 
        ' Load the process list file
        Dim counter As Integer = 0
        Dim fReader As New StreamReader(Environment.CurrentDirectory & "\times.txt")
        While Not fReader.EndOfStream
            counter += 1
            Dim delim() As Char = {" ", vbTab}
            Dim cols() As String = fReader.ReadLine.Split(delim, StringSplitOptions.RemoveEmptyEntries)
            ProcessList.Enqueue(New ProcessClass(counter, CInt(cols(0)), CType(cols(1), Single)))
        End While
 
        ' begin queuing up processes
        ReadyListThread = New Threading.Thread(AddressOf ProcessArrives)
        ReadyListThread.Start()
 
        ' begin scheduling processes
        SchedulerThread = New Threading.Thread(AddressOf ScheduleReadyProcess)
        SchedulerThread.Start()
 
    End Sub
 
End Module