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"))))
|