When Larceny is first started, timer interrupts are turned off, and the countdown timer is set to its maximum value. It is not good to leave interrupts off permanently, since a timer interrupt in a critical section will cause the timer to be reset to some small value in order to allow the computation to make progress. However, since the value is small, there will be another timer interrupt soon, so overall performance may be worse than usual from the interrupt handling overhead. This is not a problem if interrupts will be enabled in the near future and handled properly, but it may cause performance problems if interrupts are permanently disabled.

    (enable-interrupts timer-value)  =>  unspecified

Timer interrupts are turned off with the disable-interrupts procedure:

    (disable-interrupts)  =>  ticks-remaining

The procedure interrupt-handler can be used to get and set the currently installed interrupt handler:

    (interrupt-handler)  =>  handler
    (interrupt-handler handler)  => old-handler

Finally, a predefined procedure call-without-interrupts runs a procedure with interrupts turned off, i.e., in a critical section:

    (call-without-interrupts thunk)  => object

3. Examples

   (define (setup-service-routine thunk k)
     (let ((old-handler (interrupt-handler)))
       (interrupt-handler (lambda (type)
                            (if (eq? type 'timer)
                                (begin (thunk)
                                       (enable-interrupts k))
	                        (old-handler type))))
       (enable-interrupts k)))

Notice how the new interrupt handler calls the old interrupt handler if the interrupt was not a timer interrupt; this is so that the new handler does not disable other system functionality (notably handling of keyboard interrups, which are also handled by the common interrupt handler).

If the service routine needs to access data that is used by the procedures in main thread of computation, then the latter procedures can use critical sections to guard against race conditions. Consider the following program, which maintains a list of data, and a service routine that occasionally computes the length of the list.

   (define l '())        ; shared global
   (define n '())        ; used by service routine only

   (define (main-thread input)
     (setup-service-routine 
       (lambda () 
         (set! n (cons (length l) n)))
       10000)
     (loop input))

   (define (loop input)
     (do ((x (read input) (read input)))
         ((= x 0))
       (if (> x 0)
	   (call-without-interrupts
             (lambda ()
               (set! l (cons x l))))
           (call-without-interrupts
             (lambda ()
               (set! l (remove! x l)))))))

4. Some things to watch out for

5. Implementation