summaryrefslogtreecommitdiff
path: root/fibers/posix-clocks.scm
blob: dcdcf6d280d287293f8bcd5e7cebf0cd73189e65 (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
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))))))