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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
;; POSIX clocks
;;;; Copyright (C) 2016 Andy Wingo <wingo@pobox.com>
;;;;
;;;; 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
;;; Fibers uses POSIX clocks to be able to preempt schedulers running
;;; in other threads after regular timeouts in terms of thread CPU time.
(define-module (fibers posix-clocks)
#:use-module (system foreign)
#:use-module (ice-9 match)
#:use-module (rnrs bytevectors)
#:export (CLOCK_REALTIME
CLOCK_MONOTONIC
CLOCK_PROCESS_CPUTIME_ID
CLOCK_THREAD_CPUTIME_ID
CLOCK_MONOTONIC_RAW
CLOCK_REALTIME_COARSE
CLOCK_MONOTONIC_COARSE
clock-getcpuclockid
pthread-getcpuclockid
pthread-self
clock-getres
clock-gettime
clock-nanosleep))
(define exe (dynamic-link))
(define clockid-t int32)
(define time-t long)
(define pid-t int)
(define pthread-t unsigned-long)
(define struct-timespec (list time-t long))
(define TIMER_ABSTIME 1)
(define CLOCK_REALTIME 0)
(define CLOCK_MONOTONIC 1)
(define CLOCK_PROCESS_CPUTIME_ID 2)
(define CLOCK_THREAD_CPUTIME_ID 3)
(define CLOCK_MONOTONIC_RAW 4)
(define CLOCK_REALTIME_COARSE 5)
(define CLOCK_MONOTONIC_COARSE 6)
(define clock-getcpuclockid
(let* ((ptr (dynamic-pointer "clock_getcpuclockid" exe))
(proc (pointer->procedure int ptr (list pid-t '*)
#:return-errno? #t)))
(lambda* (pid #:optional (buf (make-bytevector (sizeof clockid-t))))
(call-with-values (lambda () (proc pid (bytevector->pointer buf)))
(lambda (ret errno)
(unless (zero? ret) (error (strerror errno)))
(bytevector-s32-native-ref buf 0))))))
(define pthread-self
(let* ((ptr (dynamic-pointer "pthread_self" exe))
(proc (pointer->procedure pthread-t ptr '())))
(lambda ()
(proc))))
(define pthread-getcpuclockid
(let* ((ptr (dynamic-pointer "pthread_getcpuclockid" exe))
(proc (pointer->procedure int ptr (list pthread-t '*)
#:return-errno? #t)))
(lambda* (pthread #:optional (buf (make-bytevector (sizeof clockid-t))))
(call-with-values (lambda () (proc pthread (bytevector->pointer buf)))
(lambda (ret errno)
(unless (zero? ret) (error (strerror errno)))
(bytevector-s32-native-ref buf 0))))))
(define clock-getres
(let* ((ptr (dynamic-pointer "clock_getres" exe))
(proc (pointer->procedure int ptr (list clockid-t '*)
#:return-errno? #t)))
(lambda* (clockid #:optional (buf (nsec->timespec 0)))
(call-with-values (lambda () (proc clockid buf))
(lambda (ret errno)
(unless (zero? ret) (error (strerror errno)))
(timespec->nsec buf))))))
(define clock-gettime
(let* ((ptr (dynamic-pointer "clock_gettime" exe))
(proc (pointer->procedure int ptr (list clockid-t '*)
#:return-errno? #t)))
(lambda* (clockid #:optional (buf (nsec->timespec 0)))
(call-with-values (lambda () (proc clockid buf))
(lambda (ret errno)
(unless (zero? ret) (error (strerror errno)))
(timespec->nsec buf))))))
(define (nsec->timespec nsec)
(make-c-struct struct-timespec
(list (quotient nsec #e1e9) (modulo nsec #e1e9))))
(define (timespec->nsec ts)
(match (parse-c-struct ts struct-timespec)
((sec nsec)
(+ (* sec #e1e9) nsec))))
(define clock-nanosleep
(let* ((ptr (dynamic-pointer "clock_nanosleep" exe))
(proc (pointer->procedure int ptr (list clockid-t int '* '*))))
(lambda* (clockid nsec #:key absolute? (buf (nsec->timespec nsec)))
(let* ((flags (if absolute? TIMER_ABSTIME 0))
(ret (proc clockid flags buf buf)))
(cond
((zero? ret) (values #t 0))
((eqv? ret EINTR) (values #f (timespec->nsec buf)))
(else (error (strerror ret))))))))
;; Quick little test to determine the resolution of clock-nanosleep on
;; different clock types, and how much CPU that takes. Results on
;; this 2-core, 2-thread-per-core skylake laptop:
;;
;; Clock type | Applied Hz | Actual Hz | CPU time overhead (%)
;; ---------------------------------------------------------------
;; MONOTONIC 100 98 0.4
;; MONOTONIC 1000 873 4.4
;; MONOTONIC 10000 6242 6.4
;; MONOTONIC 100000 14479 13.6
;; REALTIME 100 98 0.5
;; REALTIME 1000 872 4.5
;; REALTIME 10000 6238 6.5
;; REALTIME 100000 14590 12.2
;; PROCESS_CPUTIME 100 84 1.0
;; PROCESS_CPUTIME 10000 250 1.0
;; PROCESS_CPUTIME 100000 250 1.0
;; pthread cputime 100 84 0.9
;; pthread cputime 10000 250 0.6
;;
;; The cputime benchmarks were run with a background thread in a busy
;; loop to allow that clock to advance at the same rate as a wall
;; clock.
;;
;; Conclusions: The monotonic and realtime clocks are relatively
;; high-precision, allowing for sub-millisecond scheduling quanta, but
;; they have to be actively managed (explicitly deactivated while
;; waiting on FD events). The cputime clocks don't have to be
;; actively managed, but they aren't as high-precision either.
(define (test clock period)
(let ((start (clock-gettime CLOCK_PROCESS_CPUTIME_ID))
(until (+ (clock-gettime clock) #e1e9)))
(let lp ((n 0))
(if (< (clock-gettime clock) until)
(begin
(clock-nanosleep clock period)
(lp (1+ n)))
(values n (/ (- (clock-gettime CLOCK_PROCESS_CPUTIME_ID) start)
1e9))))))
|