Behavior of function BLOCK

[pamoroso]

From the IRM entry for function BLOCK:

Yields control to the next waiting process, assuming any is ready to run. If MSECSWAIT is specified, it is a number of milliseconds to wait before returning, or T, meaning wait forever (until explicitly woken).

Does "returning" mean function BLOCK returning? When does the function yield control, exactly? At the beginning of the call or when returning?

[nbriggs]

Yes, returning means when the function BLOCK returns. You can read the full implementation of the process world in medley/sources/PROC, but here's the definition of BLOCK:

(BLOCK
  [LAMBDA (MSECSWAIT TIMER)                              (* kbr%: " 1-Feb-86 12:12")

    (* ;; "Waits for MSECSWAIT or forever if MSECSWAIT=T.  Yields if MSECSWAIT is NIL.
           TIMER can be given as an alternative for specifying how long to wait.")

    (PROG ((PROC (THIS.PROCESS))
           PQUEUE)
          (RETURN (COND
                     [(type? PROCESS PROC)
                      (COND
                         ((AND (NULL MSECSWAIT)
                               (NULL TIMER))                 (* ; 
                                                           "Only yielding, not going to sleep")
                          (UNINTERRUPTABLY
                              (SETQ PQUEUE (fetch PROCQUEUE of PROC))
                              (COND
                                 ((NEQ PROC (fetch PQNEXT of PQUEUE))
                                  (\MP.ERROR \MP.PROCERROR "Current process is not its queue's NEXT"
                                         PROC)))
                              (replace WAKEREASON of PROC with T)
                              (replace PQNEXT of PQUEUE with (fetch NEXTPROCHANDLE
                                                                            of PROC))
                              (replace PQLAST of PQUEUE with PROC)
                              (\RESCHEDULE PROC)))
                         (T (\PROCESS.GO.TO.SLEEP NIL (COND
                                                             (TIMER (\DTEST TIMER 'FIXP))
                                                             ((FIXP MSECSWAIT)
                                                              (IMIN MSECSWAIT MAX.FIXP)))
                                   (NEQ TIMER NIL]
                     ((FIXP MSECSWAIT)                       (* ; 
                                                           "Not scheduling;  act like DISMISS")
                      (DISMISS MSECSWAIT T)
                      NIL)
                     (T (AND \WINDOWWORLD (WINDOW.MOUSE.HANDLER))
                        (for FN in BACKGROUNDFNS do (SPREADAPPLY* FN))
                        NIL])

[masinter]

There isn't a general purpose preemptive scheduler. A process retains control until it BLOCKs. Medley isn't thread-safe in its implementation, and so arbitrary interrupts will result in crashes and RAID calls.
(See warning in LispUsers PREEMPTIVE).
(Actually, there is a preemptive scheduler, but it is only used by SPY and the interrupt-character handling (control-D to reset, control-E to error, control B to break etc), wheel scroll....

access to DSK and UNIX doesn't usually block, but accesses to network file systems will.