Timers

UOS timers are used to schedule events for the future. They are general-purpose and can be used for many reasons. For the time-being, we will use them solely for the purpose of timeouts of I/O operations. This is something that the LOGIN program will use.

                        _Timers : TList ;

This instance data is added to the TUOS_SSC class. It contains an ordered list of timers. The timers are kept in ascending order of when they expire. This adds a bit of time to the creation of a timer as the SSC needs to find out where to insert the timer in the list, but it means that checking timers, which is done every system idle check, is as fast as possible: at most, only one timer that has not yet expired will be checked, since the loop through them ends as soon as it finds a timer that isn't expired yet.

// Timers...

type TUOS_Timer = class
                      public
                          Context : int64 ;
                          Time : int64 ;
                  end ;

This class implements a timer. It contains a context set by the creator of the timer and the Timestamp of when the timer expires. Note that UOS timers are one-shot, unlike timers on some other platforms.

function TUOS_SSC.Create_Timer( Context, Time : int64 ) : int64 ;

var I : integer ;
    Timer, tTimer : TUOS_Timer ;

begin
    if( _Timers = nil ) then
    begin
        _Timers := TList.Create ;
    end ;

    // Create the timer...
    Timer := TUOS_Timer.Create ;
    Result := int64( Timer ) ;
    Timer.Context := Context ;
    Timer.Time := Time ;

    // Insert into queue...
    for I := 0 to _Timers.Count - 1 do
    begin
        tTimer := TUOS_Timer( _Timers[ I ] ) ;
        if( Time < tTimer.Time ) then
        begin
            _Timers.Insert( I, Timer ) ;
            exit ;
        end ;
    end ;
    _Timers.Add( Timer ) ; // Goes at end of the list
end ; // TUOS_SSC.Create_Timer


procedure TUOS_SSC.Delete_Timer( ID : int64 ) ;

var I : integer ;

begin
    if( _Timers = nil ) then
    begin
        exit ;
    end ;
    I := _Timers.Indexof( pointer( ID ) ) ;
    if( I <> -1 ) then
    begin
        _Timers.Delete( I ) ;
    end ;
end ;


function TUOS_SSC.Timer_Count : integer ;

begin
    if( _Timers = nil ) then
    begin
        Result := 0 ;
    end else
    begin
        Result := _Timers.Count ;
    end ;
end ;


procedure TUOS_SSC.Get_Timer_Info( ID : int64 ; var Context, Time : int64 ) ;

var I : integer ;
    Timer : TUOS_Timer ;

begin
    Context := 0 ;
    if( _Timers <> nil ) then
    begin
        I := _Timers.Indexof( pointer( ID ) ) ;
        if( I <> -1 ) then
        begin
            Timer := TUOS_Timer( _Timers[ I ] ) ;
            Context := Timer.Context ;
            Time := Timer.Time ;
        end ;
    end ;
end ;


function TUOS_SSC.Get_Timer_By_Index( Index : integer ) : int64 ;

begin
    Result := 0 ;
    if( ( _Timers = nil ) or ( Index < 0 ) or ( Index >= _Timers.Count ) ) then
    begin
        exit ;
    end ;
    Result := int64( _Timers[ Index ] ) ;
end ;

These functions manage the timers list. There isn't much to comment on - the code is straight forward. The only thing of note is the Create_Timer method which searches the list for the place to insert the new timer, so that the list stays in timestamp order.

procedure TUOS_SSC.Check_Timers ;

var I : integer ;
    Timer : TUOS_Timer ;
    TS : int64 ;

begin
    if( _Timers = nil ) then
    begin
        exit ;
    end ;
    TS := Kernel.HAL.Timestamp ;
    while( _Timers.Count > 0 ) do
    begin
        Timer := TUOS_Timer( _Timers[ 0 ] ) ;
        if( Timer.Time > TS ) then // No more timers to process
        begin
            exit ;
        end ;
        _Timers.Delete( 0 ) ; // Remove timer from queue
        Kernel.Expired_Timer( int64( Timer ), Timer.Context, Timer.Time ) ;
        Timer.Free ;
    end ; // while( _Timers.Count > 0 )
end ;

This method is called on each Kernel idle, so that the timers can be checked. As mentioned above, the routine operates quickly since the list is in order. Thus, the first item in the list is always the earliest timer to expire. If that timer's timestamp has been reached, we process the timer, remove it, and try the next one (which is now the new first one). But, if the timer isn't expired yet, none of the rest will be either, so the code can exit immediately.

When we find an expired timer, we remove it from the list, report it to the kernel, and then destroy the timer instance.

procedure TKernel.Expired_Timer( Timer, Context, Time : int64 ) ;

begin
    FIP.Expired_Timer( Timer, Context, Time ) ;
end ;

At present, this kernel method does nothing more than call the FIP method for handling expired timers. It will do more in the future.

procedure TUOS_FiP.Expired_Timer( Timer, Context, Time : int64 ) ;

var I : integer ;
    Request : TUOS_IO_Request ;

begin
    for I := 0 to Pending_IOs.Count - 1 do
    begin
        Request := Pending_IOs[ I ] ;
        if( Request.Timer = Timer ) then // Found a match
        begin
            if( Request.IOSB <> 0 ) then
            begin
                PIOSB( pointer( Request.IOSB ) )^.r_io_64.w_status := SS_TIMEOUT ;
            end ;
            USC.Set_Process_Exception( Request.PID, Create_Simple_UE( UOS_Facility_ID, 0, SS_TIMEOUT, 
                Error_Fatal, '', '' ) ) ;
            TDevice( TResource( Request.Handle )._Device ).Pending_IOs.Remove( Request ) ;
            Pending_IOs.Remove( Request ) ;
            exit ;
        end ;
    end ;
end ;

This method iterates through the I/O queue, looking for a request that has the timer that was passed. This indicates that the I/O request has timed-out. In this case, we set the status of the IOSB associated with the request, set the process' exception, and remove the request from the FIP I/O queue and appropriate device I/O queue.

                                for R := 0 to Device.Pending_IOs.Count - 1 do
                                begin
                                    Request := TUOS_IO_Request( Device.Pending_IOs[ R ] ) ;
                                    if( Request.IO = 0 ) then // Read request
                                    begin
                                        if( Got_Delimiter ) then
                                        begin
                                            if( Request.Timeout <> 0 ) then // Timeout
                                            begin
                                                SSC.Delete_Timer( Request.Timer ) ;
                                            end ;
                                            Request.State := IOState_Done ;
                                        end else
                                        if( Request.Timeout <> 0 ) then // Timeout
                                        begin
                                            // Restart timeout...
                                            SSC.Delete_Timer( Request.Timer ) ;
                                            Request.Timer :=
                                                SSC.Create_Timer( 0, HAL.Timestamp + Request.Timeout ) ;
                                        end ;
                                    end ; // if( Request.IO = 0 )
                                end ; // for R := 0 to Device.Pending_IOs.Count - 1

This code is added to the TUOS_FiP.Interrupt method. When processing a read operation from a terminal, we loop through the device's I/O requests and see if there were any read operations on the device with a timeout. Timeouts are reset each time data is presented from the hardware. This is done by deleting the old timer and creating a new one with a new timestamp. Thus, timeouts are measured from the last data received, not from the initial time of the request (unless no data is received since the request was made).

In the next article, we will discuss the LOGIN CUSP.