summaryrefslogtreecommitdiff
path: root/fibers.scm
blob: c3d9414600b9faa8c62ad7c756b38a3b643fc446 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
;; Fibers: cooperative, event-driven user-space threads.

;;;; Copyright (C) 2016 Free Software Foundation, Inc.
;;;; 
;;;; This library is free software; you can redistribute it and/or
;;;; modify it under the terms of the GNU Lesser General Public
;;;; License as published by the Free Software Foundation; either
;;;; version 3 of the License, or (at your option) any later version.
;;;; 
;;;; This library is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
;;;; Lesser General Public License for more details.
;;;; 
;;;; You should have received a copy of the GNU Lesser General Public
;;;; License along with this library; if not, write to the Free Software
;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
;;;; 

(define-module (fibers)
  #:use-module (ice-9 match)
  #:use-module (ice-9 atomic)
  #:use-module (fibers internal)
  #:use-module (fibers repl)
  #:use-module (fibers timers)
  #:use-module (fibers interrupts)
  #:use-module ((ice-9 threads)
                #:select (current-thread current-processor-count))
  #:use-module ((ice-9 ports internal)
                #:select (port-read-wait-fd port-write-wait-fd))
  #:use-module (ice-9 suspendable-ports)
  #:export (run-fibers spawn-fiber)
  #:re-export (current-fiber sleep))

(define (wait-for-readable port)
  (suspend-current-fiber
   (lambda (fiber)
     (resume-on-readable-fd (port-read-wait-fd port) fiber))))
(define (wait-for-writable port)
  (suspend-current-fiber
   (lambda (fiber)
     (resume-on-writable-fd (port-read-wait-fd port) fiber))))

(define (%run-fibers scheduler hz finished?)
  (with-scheduler
   scheduler
   (parameterize ((current-read-waiter wait-for-readable)
                  (current-write-waiter wait-for-writable))
     (with-interrupts
      hz yield-current-fiber
      (lambda ()
        (run-scheduler scheduler finished?))))))

(define (start-auxiliary-threads scheduler hz finished?)
  (let ((scheds (scheduler-remote-peers scheduler)))
    (let lp ((i 0))
      (when (< i (vector-length scheds))
        (let ((remote (vector-ref scheds i)))
          (call-with-new-thread
           (lambda ()
             (%run-fibers remote hz finished?)))
          (lp (1+ i)))))))

(define (stop-auxiliary-threads scheduler)
  (let ((scheds (scheduler-remote-peers scheduler)))
    (let lp ((i 0))
      (when (< i (vector-length scheds))
        (let* ((remote (vector-ref scheds i))
               (thread (scheduler-kernel-thread remote)))
          (when thread
            (cancel-thread thread)
            (join-thread thread))
          (lp (1+ i)))))))

(define* (run-fibers #:optional (init #f)
                     #:key (hz 0) (scheduler #f)
                     (parallelism (current-processor-count))
                     (install-suspendable-ports? #t))
  (when install-suspendable-ports? (install-suspendable-ports!))
  (cond
   (scheduler
    (let ((finished? (lambda () #f)))
      (when init (spawn-fiber init scheduler))
      (%run-fibers scheduler hz finished?)))
   (else
    (let* ((scheduler (make-scheduler #:parallelism parallelism))
           (ret (make-atomic-box #f))
           (finished? (lambda () (atomic-box-ref ret))))
      (unless init
        (error "run-fibers requires initial fiber thunk when creating sched"))
      (spawn-fiber (lambda ()
                     (call-with-values init
                       (lambda vals (atomic-box-set! ret vals))))
                   scheduler)
      (start-auxiliary-threads scheduler hz finished?)
      (%run-fibers scheduler hz finished?)
      (stop-auxiliary-threads scheduler)
      (destroy-scheduler scheduler)
      (apply values (atomic-box-ref ret))))))

(define* (spawn-fiber thunk #:optional sched #:key parallel?)
  (define (choose-sched sched)
    (let* ((remote (scheduler-remote-peers sched))
           (count (vector-length remote))
           (idx (random (1+ count))))
      (if (= count idx)
          sched
          (vector-ref remote idx))))
  (define (spawn sched thunk)
    (create-fiber (if parallel? (choose-sched sched) sched)
                  thunk
                  (current-dynamic-state)))
  (cond
   (sched
    ;; When a scheduler is passed explicitly, it could be there is no
    ;; current fiber; in that case the dynamic state probably doesn't
    ;; have the right right current-read-waiter /
    ;; current-write-waiter, so wrap the thunk.
    (spawn sched
           (lambda ()
             (current-read-waiter wait-for-readable)
             (current-write-waiter wait-for-writable)
             (thunk))))
   ((current-fiber)
    => (lambda (fiber)
         (spawn (fiber-scheduler fiber) thunk)))
   (else
    (error "No scheduler current; call within run-fibers instead"))))