#lang racket
;;; Example 6bbb - Selective Accepts with Internal State (with an implicit
;;; process type)

(require (planet williams/simulation/simulation))

;;; process* (lock) (locked?)
;;;   locked? : boolean? = #f
;;; entry (lock) -> void?
;;; entry (unlock) -> void?
(define-process* (lock)
  ((locked? #f))
  (let loop ()
    (select
      ((when (not (lock-locked? self))
         (accept caller (lock)))
       (set-lock-locked?! self #t))
      ((when (lock-locked? self)
         (accept caller (unlock)))
       (set-lock-locked?! self #f)))
    (loop)))

;;; process (p1 i a-lock)
;;;   i : exact-nonnegative-integer?
;;;   a-lock : process?
;;; This process uses the lock to protect its critical region, which just does a
;;; random wait in this case.
(define-process (p1 i a-lock)
  (printf "~a: process p1(~a) started.~n"
          (current-simulation-time) i)
  (call a-lock (lock))
  (printf "~a: process p1(~a) acquired lock.~n"
          (current-simulation-time) i)
  (wait (random-flat 0.0 10.0))
  (printf "~a: process p1(~a) releasing lock.~n"
          (current-simulation-time) i)
  (call a-lock (unlock)))

;;; (main n) -> void?
;;;   n : exact-nonnegative-integer?
;;; Creates the lock process and schedules n p1 processes that use the lock.
(define (main n)
  (with-new-simulation-environment
    (let ((a-lock (schedule #:now (lock))))
      (for ((i (in-range n)))
        (schedule #:at (random-flat 0.0 10.0) (p1 i a-lock)))
      (start-simulation))))

;;; Test with 10 p1 processes.
(main 10)