libev_scheduler 0.1 → 0.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/.github/workflows/test.yml +25 -0
- data/CHANGELOG.md +3 -0
- data/Gemfile.lock +1 -1
- data/README.md +201 -2
- data/ext/libev/Changes +71 -2
- data/ext/libev/ev.c +625 -201
- data/ext/libev/ev.h +25 -22
- data/ext/libev/ev_epoll.c +16 -14
- data/ext/libev/ev_iouring.c +694 -0
- data/ext/libev/ev_kqueue.c +4 -4
- data/ext/libev/ev_linuxaio.c +78 -100
- data/ext/libev/ev_poll.c +6 -6
- data/ext/libev/ev_port.c +3 -3
- data/ext/libev/ev_select.c +6 -6
- data/ext/libev/ev_vars.h +34 -0
- data/ext/libev/ev_win32.c +2 -2
- data/ext/libev/ev_wrap.h +56 -0
- data/lib/libev_scheduler/version.rb +1 -1
- metadata +4 -3
- data/.github/test.yml +0 -31
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA256:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 921cd6937f62740e46edef5d1b3d135112276bab83149f896afb4ea6961a2f3f
|
|
4
|
+
data.tar.gz: afc0691185932a84c55ceac285eb24cb393f249e4c05176e744b4b3672a0e6c6
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: cccc65981647ef19401aa9e168e7a9137a2cddbe93e15a5061329b1cdc17e63ba1bbb62758ee43ceb16635021119240d77d9cc127e78763928f7d3046b243232
|
|
7
|
+
data.tar.gz: a317d8f63c2fdb83eea494809980d8b44ab584e4d32fbfd76b57e5e02b954efd0014ff4232f327cc098cb7429cafac94a790116e9ca984b1600bac5180b2e2de
|
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
name: Tests
|
|
2
|
+
|
|
3
|
+
on: [push, pull_request]
|
|
4
|
+
|
|
5
|
+
jobs:
|
|
6
|
+
test:
|
|
7
|
+
name: >-
|
|
8
|
+
libev_scheduler ${{matrix.os}}, ${{matrix.ruby}}
|
|
9
|
+
runs-on: ${{matrix.os}}
|
|
10
|
+
strategy:
|
|
11
|
+
matrix:
|
|
12
|
+
os: [ ubuntu-latest ]
|
|
13
|
+
ruby: [ head, '3.0' ]
|
|
14
|
+
steps:
|
|
15
|
+
- uses: actions/checkout@v2
|
|
16
|
+
- name: Set up Ruby
|
|
17
|
+
uses: actions/setup-ruby@v1
|
|
18
|
+
with:
|
|
19
|
+
ruby-version: ${{matrix.ruby}}
|
|
20
|
+
- name: Install dependencies
|
|
21
|
+
run: bundle install
|
|
22
|
+
- name: Compile C-extension
|
|
23
|
+
run: bundle exec rake compile
|
|
24
|
+
- name: Run tests
|
|
25
|
+
run: bundle exec rake test
|
data/CHANGELOG.md
CHANGED
data/Gemfile.lock
CHANGED
data/README.md
CHANGED
|
@@ -1,5 +1,204 @@
|
|
|
1
1
|
# libev_scheduler
|
|
2
2
|
|
|
3
|
-
|
|
3
|
+
<p align="center">
|
|
4
|
+
<a href="http://rubygems.org/gems/libev_scheduler">
|
|
5
|
+
<img src="https://badge.fury.io/rb/libev_scheduler.svg" alt="Ruby gem">
|
|
6
|
+
</a>
|
|
7
|
+
<a href="https://github.com/digital-fabric/libev_scheduler/actions?query=workflow%3ATests">
|
|
8
|
+
<img src="https://github.com/digital-fabric/libev_scheduler/workflows/Tests/badge.svg" alt="Tests">
|
|
9
|
+
</a>
|
|
10
|
+
<a href="https://github.com/digital-fabric/libev_scheduler/blob/master/LICENSE">
|
|
11
|
+
<img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT License">
|
|
12
|
+
</a>
|
|
13
|
+
</p>
|
|
4
14
|
|
|
5
|
-
|
|
15
|
+
`libev_scheduler` is a libev-based fiber scheduler for Ruby 3.0 based on code
|
|
16
|
+
extracted from [Polyphony](https://github.com/digital-fabric/libev_scheduler).
|
|
17
|
+
|
|
18
|
+
## Installing
|
|
19
|
+
|
|
20
|
+
```bash
|
|
21
|
+
$ gem install libev_scheduler
|
|
22
|
+
```
|
|
23
|
+
|
|
24
|
+
## Usage
|
|
25
|
+
|
|
26
|
+
```ruby
|
|
27
|
+
Fiber.set_scheduler Libev::Scheduler.new
|
|
28
|
+
|
|
29
|
+
Fiber.schedule do
|
|
30
|
+
do_something_awesome
|
|
31
|
+
end
|
|
32
|
+
```
|
|
33
|
+
|
|
34
|
+
Also have a look at the included tests and examples.
|
|
35
|
+
|
|
36
|
+
## The scheduler implementation
|
|
37
|
+
|
|
38
|
+
The present gem uses
|
|
39
|
+
[libev](http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod) to provide a
|
|
40
|
+
performant, cross-platform fiber scheduler implementation for Ruby 3.0. The
|
|
41
|
+
bundled libev is version 4.33, which includes an (experimental) io_uring
|
|
42
|
+
backend (more below about io_uring).
|
|
43
|
+
|
|
44
|
+
## Some thoughts on the Ruby fiber scheduler interface
|
|
45
|
+
|
|
46
|
+
The fiber scheduler interface is a new feature in Ruby 3.0, aimed at
|
|
47
|
+
facilitating building fiber-based concurrent applications in Ruby. The current
|
|
48
|
+
[specification](https://docs.ruby-lang.org/en/master/Fiber/SchedulerInterface.html)
|
|
49
|
+
includes methods for:
|
|
50
|
+
|
|
51
|
+
- starting a non-blocking fiber
|
|
52
|
+
- waiting for an `IO` instance to become ready for reading or writing
|
|
53
|
+
- sleeping for a certain time duration
|
|
54
|
+
- waiting for a process to terminate
|
|
55
|
+
- otherwise pausing/resuming fibers (blocking/unblocking) for use with mutexes,
|
|
56
|
+
condition variables, queues etc.
|
|
57
|
+
|
|
58
|
+
However, the current design has some shortcomings that will need to be addressed
|
|
59
|
+
in order for this feature to become useful. Here are some of my thoughts on this
|
|
60
|
+
subject. Please do not take this as an attack on the wonderful work of the Ruby
|
|
61
|
+
core developers. Most probably I'm just some random guy being wrong on the
|
|
62
|
+
internet :-p.
|
|
63
|
+
|
|
64
|
+
### Two kinds of fibers
|
|
65
|
+
|
|
66
|
+
One of the changes made as part of the work on the fiber scheduler interface in
|
|
67
|
+
Ruby 3.0 was to distinguish between two kinds of fibers: a normal, blocking
|
|
68
|
+
fiber; and a non-blocking fiber, which can be used in conjunction with the fiber
|
|
69
|
+
scheduler. While this was probably done for the sake of backward compatibility,
|
|
70
|
+
I believe this is an error. In introduces ambiguity where previously there was
|
|
71
|
+
none and makes the API more complex that it could have been.
|
|
72
|
+
|
|
73
|
+
It seems to me that a more logical solution to the problem of maintaining the
|
|
74
|
+
blocking behaviour by default, would be have been to set the non-blocking mode
|
|
75
|
+
at the level of the thread, instead of the fiber. That also would have allowed
|
|
76
|
+
using the main fiber (of a given thread) in a non-blocking manner (see below).
|
|
77
|
+
|
|
78
|
+
### Performing blocking operations on the main fiber
|
|
79
|
+
|
|
80
|
+
While I didn't scratch the surface too much in terms of the limits of the fiber
|
|
81
|
+
scheduler interface, it looks pretty clear that the main fiber (in any thread)
|
|
82
|
+
cannot be used in a non-blocking manner. While fiber scheduler implementations
|
|
83
|
+
can in principle use `Fiber#transfer` to switch between fibers, which will allow
|
|
84
|
+
pausing and resuming the main fiber, it does not seem as if the current design
|
|
85
|
+
is really conductive to that.
|
|
86
|
+
|
|
87
|
+
### I/O readiness
|
|
88
|
+
|
|
89
|
+
In and of itself, checking for I/O readiness is nice, but it does not allow us
|
|
90
|
+
to leverage the full power of io_uring on Linux or IOCP in Windows. In order to
|
|
91
|
+
leverage the advantages offered by io_uring, for instance, a fiber scheduler
|
|
92
|
+
should be able to do much more than just check for I/O readiness. It should be
|
|
93
|
+
able, rather, to *perform* I/O operations including read/write, send/recv,
|
|
94
|
+
connect and accept.
|
|
95
|
+
|
|
96
|
+
This is of course no small undertaking, but the current Ruby [native I/O
|
|
97
|
+
code](https://github.com/ruby/ruby/blob/master/io.c), currently at almost 14
|
|
98
|
+
KLOCS, is IMHO ripe for some overhauling, and maybe some separation of concerns.
|
|
99
|
+
It seems to me that the API layer for the `IO` class could be separated from the
|
|
100
|
+
code that does the actual reading/writing etc. This is indeed the approach I
|
|
101
|
+
took with [Polyphony](https://github.com/digital-fabric/polyphony/), which
|
|
102
|
+
provides the same `IO` API for developers, but performs the I/O ops using a
|
|
103
|
+
libev- or io_uring-based backend. This design can then reap all of the benefits
|
|
104
|
+
of using io_uring. Such an approach could also allow us to implement I/O using
|
|
105
|
+
IOCP on Windows (currently we can't because this requires files to be opened
|
|
106
|
+
with `WSA_FLAG_OVERLAPPED`).
|
|
107
|
+
|
|
108
|
+
This is also the reason I have decided not to release a native io_uring-backed
|
|
109
|
+
fiber scheduler implementation (with code extracted from Polyphony), since I
|
|
110
|
+
don't believe it can provide any real benefit in terms of performance. If I/O
|
|
111
|
+
readiness is all that the fiber scheduler can do, it's probably best to just use
|
|
112
|
+
a cross-platform implementation such as libev, which can then use io_uring
|
|
113
|
+
behind the scenes.
|
|
114
|
+
|
|
115
|
+
### Waiting for processes
|
|
116
|
+
|
|
117
|
+
The problem with the current design is that the `#process_wait` method is
|
|
118
|
+
expected to return an instance of `Process::Status`. Unfortunately, this class
|
|
119
|
+
[cannot be
|
|
120
|
+
instantiated](https://github.com/ruby/ruby/blob/master/process.c#L8678), which
|
|
121
|
+
leads to a workaround using a separate thread.
|
|
122
|
+
|
|
123
|
+
Another difficulty associated with this is that for example on libev, a child
|
|
124
|
+
watcher can only be used on the default loop, which means only in the main
|
|
125
|
+
thread, as the child watcher implementation is based on receiving `SIGCHLD`.
|
|
126
|
+
|
|
127
|
+
An alternative solution would be to use `pidfd_open` and watch the returned fd
|
|
128
|
+
for readiness, but I don't know if this can be used on OSes other than linux.
|
|
129
|
+
|
|
130
|
+
While a cross-OS solution to the latter problem is potentially not too
|
|
131
|
+
difficult, the former problem is a real show-stopper. One solution might be to
|
|
132
|
+
change the API such that `#process_wait` returns an array containing the pid and
|
|
133
|
+
its status, for example. This can then be used to instantiate a
|
|
134
|
+
`Process::Status` object somewhere inside `Process.wait`.
|
|
135
|
+
|
|
136
|
+
### On having multiple alternative fiber scheduler implementations
|
|
137
|
+
|
|
138
|
+
It is unclear to me that there is really a need for multiple fiber scheduler
|
|
139
|
+
implementations. It seems to me that an approach using multiple backends
|
|
140
|
+
selected according to the OS, is much more appropriate. It's not like there's
|
|
141
|
+
going to be a dozen different implementations of fiber schedulers. Actually,
|
|
142
|
+
libev fits really nicely here, since it already includes all those different
|
|
143
|
+
backends.
|
|
144
|
+
|
|
145
|
+
|
|
146
|
+
Besides, the term "fiber scheduler" is a bit of a misnomer, since it doesn't
|
|
147
|
+
really deal with *scheduling* fibers, but really with *performing blocking
|
|
148
|
+
operations in a fiber-aware manner*. The scheduling part is in many ways trivial
|
|
149
|
+
(i.e. the scheduler holds an array of fibers ready to run), but the performing
|
|
150
|
+
of blocking operations is [much more
|
|
151
|
+
involved](https://github.com/digital-fabric/polyphony/blob/master/ext/polyphony/backend_io_uring.c).
|
|
152
|
+
|
|
153
|
+
There is of course quite a bit of interaction between the scheduling part and
|
|
154
|
+
the blocking operations part, but then again to me a more sensible design would
|
|
155
|
+
have been to do everything related to scheduling inside of the Ruby core code,
|
|
156
|
+
and then offload everything else to a `BlockingOperationsBackend`
|
|
157
|
+
implementation. Here's what it might look like:
|
|
158
|
+
|
|
159
|
+
```ruby
|
|
160
|
+
# example pseudo-code
|
|
161
|
+
class BlockingOperationsBackend
|
|
162
|
+
def poll(opts = {})
|
|
163
|
+
ev_run(@ev_loop)
|
|
164
|
+
end
|
|
165
|
+
|
|
166
|
+
def io_wait(io, opts)
|
|
167
|
+
fiber = Fiber.current
|
|
168
|
+
watcher = setup_watcher_for_io(io) do
|
|
169
|
+
Thread.current.schedule_fiber(fiber)
|
|
170
|
+
end
|
|
171
|
+
Fiber.yield
|
|
172
|
+
watcher.stop
|
|
173
|
+
end
|
|
174
|
+
|
|
175
|
+
...
|
|
176
|
+
end
|
|
177
|
+
```
|
|
178
|
+
|
|
179
|
+
The fiber scheduling part would provide a `Thread#schedule_fiber` method that
|
|
180
|
+
adds the given fiber to the thread's run queue, and the thread will know when to
|
|
181
|
+
call the backend's `#poll` method in order to poll for blocking operation
|
|
182
|
+
completions. For example:
|
|
183
|
+
|
|
184
|
+
```ruby
|
|
185
|
+
# somewhere in Ruby's kischkas:
|
|
186
|
+
class Thread
|
|
187
|
+
def schedule_fiber(fiber)
|
|
188
|
+
@run_queue << fiber
|
|
189
|
+
end
|
|
190
|
+
|
|
191
|
+
def run_fiber_scheduler
|
|
192
|
+
@backend.poll
|
|
193
|
+
@run_queue.each { |f| f.resume }
|
|
194
|
+
end
|
|
195
|
+
end
|
|
196
|
+
```
|
|
197
|
+
|
|
198
|
+
It seems to me this kind of design would be much easier to implement, and would
|
|
199
|
+
lead to a lot less code duplication. This design could also be extended later to
|
|
200
|
+
perform all kinds of blocking operations, such as reading/writing etc., as
|
|
201
|
+
discussed above.
|
|
202
|
+
|
|
203
|
+
Finally, such a design could also provide a C API for people writing extensions,
|
|
204
|
+
so they can rely on it whenever doing any blocking call.
|
data/ext/libev/Changes
CHANGED
|
@@ -1,8 +1,77 @@
|
|
|
1
1
|
Revision history for libev, a high-performance and full-featured event loop.
|
|
2
2
|
|
|
3
|
+
TODO: for next ABI/API change, consider moving EV__IOFDSSET into io->fd instead and provide a getter.
|
|
4
|
+
TODO: document EV_TSTAMP_T
|
|
5
|
+
|
|
6
|
+
4.33 Wed Mar 18 13:22:29 CET 2020
|
|
7
|
+
- no changes w.r.t. 4.32.
|
|
8
|
+
|
|
9
|
+
4.32 (EV only)
|
|
10
|
+
- the 4.31 timerfd code wrongly changed the priority of the signal
|
|
11
|
+
fd watcher, which is usually harmless unless signal fds are
|
|
12
|
+
also used (found via cpan tester service).
|
|
13
|
+
- the documentation wrongly claimed that user may modify fd and events
|
|
14
|
+
members in io watchers when the watcher was stopped
|
|
15
|
+
(found by b_jonas).
|
|
16
|
+
- new ev_io_modify mutator which changes only the events member,
|
|
17
|
+
which can be faster. also added ev::io::set (int events) method
|
|
18
|
+
to ev++.h.
|
|
19
|
+
- officially allow a zero events mask for io watchers. this should
|
|
20
|
+
work with older libev versions as well but was not officially
|
|
21
|
+
allowed before.
|
|
22
|
+
- do not wake up every minute when timerfd is used to detect timejumps.
|
|
23
|
+
- do not wake up every minute when periodics are disabled and we have
|
|
24
|
+
a monotonic clock.
|
|
25
|
+
- support a lot more "uncommon" compile time configurations,
|
|
26
|
+
such as ev_embed enabled but ev_timer disabled.
|
|
27
|
+
- use a start/stop wrapper class to reduce code duplication in
|
|
28
|
+
ev++.h and make it needlessly more c++-y.
|
|
29
|
+
- the linux aio backend is no longer compiled in by default.
|
|
30
|
+
- update to libecb version 0x00010008.
|
|
31
|
+
|
|
32
|
+
4.31 Fri Dec 20 21:58:29 CET 2019
|
|
33
|
+
- handle backends with minimum wait time a bit better by not
|
|
34
|
+
waiting in the presence of already-expired timers
|
|
35
|
+
(behaviour reported by Felipe Gasper).
|
|
36
|
+
- new feature: use timerfd to detect timejumps quickly,
|
|
37
|
+
can be disabled with the new EVFLAG_NOTIMERFD loop flag.
|
|
38
|
+
- document EV_USE_SIGNALFD feature macro.
|
|
39
|
+
|
|
40
|
+
4.30 (EV only)
|
|
41
|
+
- change non-autoconf test for __kernel_rwf_t by testing
|
|
42
|
+
LINUX_VERSION_CODE, the most direct test I could find.
|
|
43
|
+
- fix a bug in the io_uring backend that polled the wrong
|
|
44
|
+
backend fd, causing it to not work in many cases.
|
|
45
|
+
|
|
46
|
+
4.29 (EV only)
|
|
47
|
+
- add io uring autoconf and non-autoconf detection.
|
|
48
|
+
- disable io_uring when some header files are too old.
|
|
49
|
+
|
|
50
|
+
4.28 (EV only)
|
|
51
|
+
- linuxaio backend resulted in random memory corruption
|
|
52
|
+
when loop is forked.
|
|
53
|
+
- linuxaio backend might have tried to cancel an iocb
|
|
54
|
+
multiple times (was unable to trigger this).
|
|
55
|
+
- linuxaio backend now employs a generation counter to
|
|
56
|
+
avoid handling spurious events from cancelled requests.
|
|
57
|
+
- io_cancel can return EINTR, deal with it. also, assume
|
|
58
|
+
io_submit also returns EINTR.
|
|
59
|
+
- fix some other minor bugs in linuxaio backend.
|
|
60
|
+
- ev_tstamp type can now be overriden by defining EV_TSTAMP_T.
|
|
61
|
+
- cleanup: replace expect_true/false and noinline by their
|
|
62
|
+
libecb counterparts.
|
|
63
|
+
- move syscall infrastructure from ev_linuxaio.c to ev.c.
|
|
64
|
+
- prepare io_uring integration.
|
|
65
|
+
- tweak ev_floor.
|
|
66
|
+
- epoll, poll, win32 Sleep and other places that use millisecond
|
|
67
|
+
reslution now all try to round up times.
|
|
68
|
+
- solaris port backend didn't compile.
|
|
69
|
+
- abstract time constants into their macros, for more flexibility.
|
|
70
|
+
|
|
3
71
|
4.27 Thu Jun 27 22:43:44 CEST 2019
|
|
4
|
-
- linux aio backend almost
|
|
72
|
+
- linux aio backend almost completely rewritten to work around its
|
|
5
73
|
limitations.
|
|
74
|
+
- linux aio backend now requires linux 4.19+.
|
|
6
75
|
- epoll backend now mandatory for linux aio backend.
|
|
7
76
|
- fail assertions more aggressively on invalid fd's detected
|
|
8
77
|
in the event loop, do not just silently fd_kill in case of
|
|
@@ -22,7 +91,7 @@ Revision history for libev, a high-performance and full-featured event loop.
|
|
|
22
91
|
4.25 Fri Dec 21 07:49:20 CET 2018
|
|
23
92
|
- INCOMPATIBLE CHANGE: EV_THROW was renamed to EV_NOEXCEPT
|
|
24
93
|
(EV_THROW still provided) and now uses noexcept on C++11 or newer.
|
|
25
|
-
- move the darwin select workaround
|
|
94
|
+
- move the darwin select workaround higher in ev.c, as newer versions of
|
|
26
95
|
darwin managed to break their broken select even more.
|
|
27
96
|
- ANDROID => __ANDROID__ (reported by enh@google.com).
|
|
28
97
|
- disable epoll_create1 on android because it has broken header files
|
data/ext/libev/ev.c
CHANGED
|
@@ -116,7 +116,7 @@
|
|
|
116
116
|
# undef EV_USE_POLL
|
|
117
117
|
# define EV_USE_POLL 0
|
|
118
118
|
# endif
|
|
119
|
-
|
|
119
|
+
|
|
120
120
|
# if HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H
|
|
121
121
|
# ifndef EV_USE_EPOLL
|
|
122
122
|
# define EV_USE_EPOLL EV_FEATURE_BACKENDS
|
|
@@ -125,16 +125,25 @@
|
|
|
125
125
|
# undef EV_USE_EPOLL
|
|
126
126
|
# define EV_USE_EPOLL 0
|
|
127
127
|
# endif
|
|
128
|
-
|
|
128
|
+
|
|
129
129
|
# if HAVE_LINUX_AIO_ABI_H
|
|
130
130
|
# ifndef EV_USE_LINUXAIO
|
|
131
|
-
# define EV_USE_LINUXAIO EV_FEATURE_BACKENDS
|
|
131
|
+
# define EV_USE_LINUXAIO 0 /* was: EV_FEATURE_BACKENDS, always off by default */
|
|
132
132
|
# endif
|
|
133
133
|
# else
|
|
134
134
|
# undef EV_USE_LINUXAIO
|
|
135
135
|
# define EV_USE_LINUXAIO 0
|
|
136
136
|
# endif
|
|
137
|
-
|
|
137
|
+
|
|
138
|
+
# if HAVE_LINUX_FS_H && HAVE_SYS_TIMERFD_H && HAVE_KERNEL_RWF_T
|
|
139
|
+
# ifndef EV_USE_IOURING
|
|
140
|
+
# define EV_USE_IOURING EV_FEATURE_BACKENDS
|
|
141
|
+
# endif
|
|
142
|
+
# else
|
|
143
|
+
# undef EV_USE_IOURING
|
|
144
|
+
# define EV_USE_IOURING 0
|
|
145
|
+
# endif
|
|
146
|
+
|
|
138
147
|
# if HAVE_KQUEUE && HAVE_SYS_EVENT_H
|
|
139
148
|
# ifndef EV_USE_KQUEUE
|
|
140
149
|
# define EV_USE_KQUEUE EV_FEATURE_BACKENDS
|
|
@@ -143,7 +152,7 @@
|
|
|
143
152
|
# undef EV_USE_KQUEUE
|
|
144
153
|
# define EV_USE_KQUEUE 0
|
|
145
154
|
# endif
|
|
146
|
-
|
|
155
|
+
|
|
147
156
|
# if HAVE_PORT_H && HAVE_PORT_CREATE
|
|
148
157
|
# ifndef EV_USE_PORT
|
|
149
158
|
# define EV_USE_PORT EV_FEATURE_BACKENDS
|
|
@@ -179,7 +188,16 @@
|
|
|
179
188
|
# undef EV_USE_EVENTFD
|
|
180
189
|
# define EV_USE_EVENTFD 0
|
|
181
190
|
# endif
|
|
182
|
-
|
|
191
|
+
|
|
192
|
+
# if HAVE_SYS_TIMERFD_H
|
|
193
|
+
# ifndef EV_USE_TIMERFD
|
|
194
|
+
# define EV_USE_TIMERFD EV_FEATURE_OS
|
|
195
|
+
# endif
|
|
196
|
+
# else
|
|
197
|
+
# undef EV_USE_TIMERFD
|
|
198
|
+
# define EV_USE_TIMERFD 0
|
|
199
|
+
# endif
|
|
200
|
+
|
|
183
201
|
#endif
|
|
184
202
|
|
|
185
203
|
/* OS X, in its infinite idiocy, actually HARDCODES
|
|
@@ -335,6 +353,22 @@
|
|
|
335
353
|
# define EV_USE_PORT 0
|
|
336
354
|
#endif
|
|
337
355
|
|
|
356
|
+
#ifndef EV_USE_LINUXAIO
|
|
357
|
+
# if __linux /* libev currently assumes linux/aio_abi.h is always available on linux */
|
|
358
|
+
# define EV_USE_LINUXAIO 0 /* was: 1, always off by default */
|
|
359
|
+
# else
|
|
360
|
+
# define EV_USE_LINUXAIO 0
|
|
361
|
+
# endif
|
|
362
|
+
#endif
|
|
363
|
+
|
|
364
|
+
#ifndef EV_USE_IOURING
|
|
365
|
+
# if __linux /* later checks might disable again */
|
|
366
|
+
# define EV_USE_IOURING 1
|
|
367
|
+
# else
|
|
368
|
+
# define EV_USE_IOURING 0
|
|
369
|
+
# endif
|
|
370
|
+
#endif
|
|
371
|
+
|
|
338
372
|
#ifndef EV_USE_INOTIFY
|
|
339
373
|
# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
|
|
340
374
|
# define EV_USE_INOTIFY EV_FEATURE_OS
|
|
@@ -367,6 +401,14 @@
|
|
|
367
401
|
# endif
|
|
368
402
|
#endif
|
|
369
403
|
|
|
404
|
+
#ifndef EV_USE_TIMERFD
|
|
405
|
+
# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8))
|
|
406
|
+
# define EV_USE_TIMERFD EV_FEATURE_OS
|
|
407
|
+
# else
|
|
408
|
+
# define EV_USE_TIMERFD 0
|
|
409
|
+
# endif
|
|
410
|
+
#endif
|
|
411
|
+
|
|
370
412
|
#if 0 /* debugging */
|
|
371
413
|
# define EV_VERIFY 3
|
|
372
414
|
# define EV_USE_4HEAP 1
|
|
@@ -409,6 +451,7 @@
|
|
|
409
451
|
# define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))
|
|
410
452
|
# undef EV_USE_MONOTONIC
|
|
411
453
|
# define EV_USE_MONOTONIC 1
|
|
454
|
+
# define EV_NEED_SYSCALL 1
|
|
412
455
|
# else
|
|
413
456
|
# undef EV_USE_CLOCK_SYSCALL
|
|
414
457
|
# define EV_USE_CLOCK_SYSCALL 0
|
|
@@ -432,6 +475,14 @@
|
|
|
432
475
|
# define EV_USE_INOTIFY 0
|
|
433
476
|
#endif
|
|
434
477
|
|
|
478
|
+
#if __linux && EV_USE_IOURING
|
|
479
|
+
# include <linux/version.h>
|
|
480
|
+
# if LINUX_VERSION_CODE < KERNEL_VERSION(4,14,0)
|
|
481
|
+
# undef EV_USE_IOURING
|
|
482
|
+
# define EV_USE_IOURING 0
|
|
483
|
+
# endif
|
|
484
|
+
#endif
|
|
485
|
+
|
|
435
486
|
#if !EV_USE_NANOSLEEP
|
|
436
487
|
/* hp-ux has it in sys/time.h, which we unconditionally include above */
|
|
437
488
|
# if !defined _WIN32 && !defined __hpux
|
|
@@ -441,12 +492,29 @@
|
|
|
441
492
|
|
|
442
493
|
#if EV_USE_LINUXAIO
|
|
443
494
|
# include <sys/syscall.h>
|
|
444
|
-
# if
|
|
495
|
+
# if SYS_io_getevents && EV_USE_EPOLL /* linuxaio backend requires epoll backend */
|
|
496
|
+
# define EV_NEED_SYSCALL 1
|
|
497
|
+
# else
|
|
445
498
|
# undef EV_USE_LINUXAIO
|
|
446
499
|
# define EV_USE_LINUXAIO 0
|
|
447
500
|
# endif
|
|
448
501
|
#endif
|
|
449
502
|
|
|
503
|
+
#if EV_USE_IOURING
|
|
504
|
+
# include <sys/syscall.h>
|
|
505
|
+
# if !SYS_io_uring_setup && __linux && !__alpha
|
|
506
|
+
# define SYS_io_uring_setup 425
|
|
507
|
+
# define SYS_io_uring_enter 426
|
|
508
|
+
# define SYS_io_uring_wregister 427
|
|
509
|
+
# endif
|
|
510
|
+
# if SYS_io_uring_setup && EV_USE_EPOLL /* iouring backend requires epoll backend */
|
|
511
|
+
# define EV_NEED_SYSCALL 1
|
|
512
|
+
# else
|
|
513
|
+
# undef EV_USE_IOURING
|
|
514
|
+
# define EV_USE_IOURING 0
|
|
515
|
+
# endif
|
|
516
|
+
#endif
|
|
517
|
+
|
|
450
518
|
#if EV_USE_INOTIFY
|
|
451
519
|
# include <sys/statfs.h>
|
|
452
520
|
# include <sys/inotify.h>
|
|
@@ -458,7 +526,7 @@
|
|
|
458
526
|
#endif
|
|
459
527
|
|
|
460
528
|
#if EV_USE_EVENTFD
|
|
461
|
-
/* our minimum requirement is glibc 2.7 which has the stub, but not the header */
|
|
529
|
+
/* our minimum requirement is glibc 2.7 which has the stub, but not the full header */
|
|
462
530
|
# include <stdint.h>
|
|
463
531
|
# ifndef EFD_NONBLOCK
|
|
464
532
|
# define EFD_NONBLOCK O_NONBLOCK
|
|
@@ -474,7 +542,7 @@ EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags);
|
|
|
474
542
|
#endif
|
|
475
543
|
|
|
476
544
|
#if EV_USE_SIGNALFD
|
|
477
|
-
/* our minimum requirement is glibc 2.7 which has the stub, but not the header */
|
|
545
|
+
/* our minimum requirement is glibc 2.7 which has the stub, but not the full header */
|
|
478
546
|
# include <stdint.h>
|
|
479
547
|
# ifndef SFD_NONBLOCK
|
|
480
548
|
# define SFD_NONBLOCK O_NONBLOCK
|
|
@@ -486,7 +554,7 @@ EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags);
|
|
|
486
554
|
# define SFD_CLOEXEC 02000000
|
|
487
555
|
# endif
|
|
488
556
|
# endif
|
|
489
|
-
EV_CPP (extern "C") int signalfd (int fd, const sigset_t *mask, int flags);
|
|
557
|
+
EV_CPP (extern "C") int (signalfd) (int fd, const sigset_t *mask, int flags);
|
|
490
558
|
|
|
491
559
|
struct signalfd_siginfo
|
|
492
560
|
{
|
|
@@ -495,7 +563,17 @@ struct signalfd_siginfo
|
|
|
495
563
|
};
|
|
496
564
|
#endif
|
|
497
565
|
|
|
498
|
-
|
|
566
|
+
/* for timerfd, libev core requires TFD_TIMER_CANCEL_ON_SET &c */
|
|
567
|
+
#if EV_USE_TIMERFD
|
|
568
|
+
# include <sys/timerfd.h>
|
|
569
|
+
/* timerfd is only used for periodics */
|
|
570
|
+
# if !(defined (TFD_TIMER_CANCEL_ON_SET) && defined (TFD_CLOEXEC) && defined (TFD_NONBLOCK)) || !EV_PERIODIC_ENABLE
|
|
571
|
+
# undef EV_USE_TIMERFD
|
|
572
|
+
# define EV_USE_TIMERFD 0
|
|
573
|
+
# endif
|
|
574
|
+
#endif
|
|
575
|
+
|
|
576
|
+
/*****************************************************************************/
|
|
499
577
|
|
|
500
578
|
#if EV_VERIFY >= 3
|
|
501
579
|
# define EV_FREQUENT_CHECK ev_verify (EV_A)
|
|
@@ -510,18 +588,34 @@ struct signalfd_siginfo
|
|
|
510
588
|
#define MIN_INTERVAL 0.0001220703125 /* 1/2**13, good till 4000 */
|
|
511
589
|
/*#define MIN_INTERVAL 0.00000095367431640625 /* 1/2**20, good till 2200 */
|
|
512
590
|
|
|
513
|
-
#define MIN_TIMEJUMP
|
|
514
|
-
#define MAX_BLOCKTIME
|
|
591
|
+
#define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */
|
|
592
|
+
#define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
|
|
593
|
+
#define MAX_BLOCKTIME2 1500001.07 /* same, but when timerfd is used to detect jumps, also safe delay to not overflow */
|
|
594
|
+
|
|
595
|
+
/* find a portable timestamp that is "always" in the future but fits into time_t.
|
|
596
|
+
* this is quite hard, and we are mostly guessing - we handle 32 bit signed/unsigned time_t,
|
|
597
|
+
* and sizes larger than 32 bit, and maybe the unlikely floating point time_t */
|
|
598
|
+
#define EV_TSTAMP_HUGE \
|
|
599
|
+
(sizeof (time_t) >= 8 ? 10000000000000. \
|
|
600
|
+
: 0 < (time_t)4294967295 ? 4294967295. \
|
|
601
|
+
: 2147483647.) \
|
|
515
602
|
|
|
516
|
-
#
|
|
517
|
-
#define
|
|
603
|
+
#ifndef EV_TS_CONST
|
|
604
|
+
# define EV_TS_CONST(nv) nv
|
|
605
|
+
# define EV_TS_TO_MSEC(a) a * 1e3 + 0.9999
|
|
606
|
+
# define EV_TS_FROM_USEC(us) us * 1e-6
|
|
607
|
+
# define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0)
|
|
608
|
+
# define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)
|
|
609
|
+
# define EV_TV_GET(tv) ((tv).tv_sec + (tv).tv_usec * 1e-6)
|
|
610
|
+
# define EV_TS_GET(ts) ((ts).tv_sec + (ts).tv_nsec * 1e-9)
|
|
611
|
+
#endif
|
|
518
612
|
|
|
519
613
|
/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */
|
|
520
614
|
/* ECB.H BEGIN */
|
|
521
615
|
/*
|
|
522
616
|
* libecb - http://software.schmorp.de/pkg/libecb
|
|
523
617
|
*
|
|
524
|
-
* Copyright (©) 2009-2015 Marc Alexander Lehmann <libecb@schmorp.de>
|
|
618
|
+
* Copyright (©) 2009-2015,2018-2020 Marc Alexander Lehmann <libecb@schmorp.de>
|
|
525
619
|
* Copyright (©) 2011 Emanuele Giaquinta
|
|
526
620
|
* All rights reserved.
|
|
527
621
|
*
|
|
@@ -562,15 +656,23 @@ struct signalfd_siginfo
|
|
|
562
656
|
#define ECB_H
|
|
563
657
|
|
|
564
658
|
/* 16 bits major, 16 bits minor */
|
|
565
|
-
#define ECB_VERSION
|
|
659
|
+
#define ECB_VERSION 0x00010008
|
|
566
660
|
|
|
567
|
-
#
|
|
661
|
+
#include <string.h> /* for memcpy */
|
|
662
|
+
|
|
663
|
+
#if defined (_WIN32) && !defined (__MINGW32__)
|
|
568
664
|
typedef signed char int8_t;
|
|
569
665
|
typedef unsigned char uint8_t;
|
|
666
|
+
typedef signed char int_fast8_t;
|
|
667
|
+
typedef unsigned char uint_fast8_t;
|
|
570
668
|
typedef signed short int16_t;
|
|
571
669
|
typedef unsigned short uint16_t;
|
|
670
|
+
typedef signed int int_fast16_t;
|
|
671
|
+
typedef unsigned int uint_fast16_t;
|
|
572
672
|
typedef signed int int32_t;
|
|
573
673
|
typedef unsigned int uint32_t;
|
|
674
|
+
typedef signed int int_fast32_t;
|
|
675
|
+
typedef unsigned int uint_fast32_t;
|
|
574
676
|
#if __GNUC__
|
|
575
677
|
typedef signed long long int64_t;
|
|
576
678
|
typedef unsigned long long uint64_t;
|
|
@@ -578,6 +680,8 @@ struct signalfd_siginfo
|
|
|
578
680
|
typedef signed __int64 int64_t;
|
|
579
681
|
typedef unsigned __int64 uint64_t;
|
|
580
682
|
#endif
|
|
683
|
+
typedef int64_t int_fast64_t;
|
|
684
|
+
typedef uint64_t uint_fast64_t;
|
|
581
685
|
#ifdef _WIN64
|
|
582
686
|
#define ECB_PTRSIZE 8
|
|
583
687
|
typedef uint64_t uintptr_t;
|
|
@@ -599,6 +703,14 @@ struct signalfd_siginfo
|
|
|
599
703
|
#define ECB_GCC_AMD64 (__amd64 || __amd64__ || __x86_64 || __x86_64__)
|
|
600
704
|
#define ECB_MSVC_AMD64 (_M_AMD64 || _M_X64)
|
|
601
705
|
|
|
706
|
+
#ifndef ECB_OPTIMIZE_SIZE
|
|
707
|
+
#if __OPTIMIZE_SIZE__
|
|
708
|
+
#define ECB_OPTIMIZE_SIZE 1
|
|
709
|
+
#else
|
|
710
|
+
#define ECB_OPTIMIZE_SIZE 0
|
|
711
|
+
#endif
|
|
712
|
+
#endif
|
|
713
|
+
|
|
602
714
|
/* work around x32 idiocy by defining proper macros */
|
|
603
715
|
#if ECB_GCC_AMD64 || ECB_MSVC_AMD64
|
|
604
716
|
#if _ILP32
|
|
@@ -1114,6 +1226,44 @@ ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { retu
|
|
|
1114
1226
|
ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }
|
|
1115
1227
|
ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
|
|
1116
1228
|
|
|
1229
|
+
#if ECB_CPP
|
|
1230
|
+
|
|
1231
|
+
inline uint8_t ecb_ctz (uint8_t v) { return ecb_ctz32 (v); }
|
|
1232
|
+
inline uint16_t ecb_ctz (uint16_t v) { return ecb_ctz32 (v); }
|
|
1233
|
+
inline uint32_t ecb_ctz (uint32_t v) { return ecb_ctz32 (v); }
|
|
1234
|
+
inline uint64_t ecb_ctz (uint64_t v) { return ecb_ctz64 (v); }
|
|
1235
|
+
|
|
1236
|
+
inline bool ecb_is_pot (uint8_t v) { return ecb_is_pot32 (v); }
|
|
1237
|
+
inline bool ecb_is_pot (uint16_t v) { return ecb_is_pot32 (v); }
|
|
1238
|
+
inline bool ecb_is_pot (uint32_t v) { return ecb_is_pot32 (v); }
|
|
1239
|
+
inline bool ecb_is_pot (uint64_t v) { return ecb_is_pot64 (v); }
|
|
1240
|
+
|
|
1241
|
+
inline int ecb_ld (uint8_t v) { return ecb_ld32 (v); }
|
|
1242
|
+
inline int ecb_ld (uint16_t v) { return ecb_ld32 (v); }
|
|
1243
|
+
inline int ecb_ld (uint32_t v) { return ecb_ld32 (v); }
|
|
1244
|
+
inline int ecb_ld (uint64_t v) { return ecb_ld64 (v); }
|
|
1245
|
+
|
|
1246
|
+
inline int ecb_popcount (uint8_t v) { return ecb_popcount32 (v); }
|
|
1247
|
+
inline int ecb_popcount (uint16_t v) { return ecb_popcount32 (v); }
|
|
1248
|
+
inline int ecb_popcount (uint32_t v) { return ecb_popcount32 (v); }
|
|
1249
|
+
inline int ecb_popcount (uint64_t v) { return ecb_popcount64 (v); }
|
|
1250
|
+
|
|
1251
|
+
inline uint8_t ecb_bitrev (uint8_t v) { return ecb_bitrev8 (v); }
|
|
1252
|
+
inline uint16_t ecb_bitrev (uint16_t v) { return ecb_bitrev16 (v); }
|
|
1253
|
+
inline uint32_t ecb_bitrev (uint32_t v) { return ecb_bitrev32 (v); }
|
|
1254
|
+
|
|
1255
|
+
inline uint8_t ecb_rotl (uint8_t v, unsigned int count) { return ecb_rotl8 (v, count); }
|
|
1256
|
+
inline uint16_t ecb_rotl (uint16_t v, unsigned int count) { return ecb_rotl16 (v, count); }
|
|
1257
|
+
inline uint32_t ecb_rotl (uint32_t v, unsigned int count) { return ecb_rotl32 (v, count); }
|
|
1258
|
+
inline uint64_t ecb_rotl (uint64_t v, unsigned int count) { return ecb_rotl64 (v, count); }
|
|
1259
|
+
|
|
1260
|
+
inline uint8_t ecb_rotr (uint8_t v, unsigned int count) { return ecb_rotr8 (v, count); }
|
|
1261
|
+
inline uint16_t ecb_rotr (uint16_t v, unsigned int count) { return ecb_rotr16 (v, count); }
|
|
1262
|
+
inline uint32_t ecb_rotr (uint32_t v, unsigned int count) { return ecb_rotr32 (v, count); }
|
|
1263
|
+
inline uint64_t ecb_rotr (uint64_t v, unsigned int count) { return ecb_rotr64 (v, count); }
|
|
1264
|
+
|
|
1265
|
+
#endif
|
|
1266
|
+
|
|
1117
1267
|
#if ECB_GCC_VERSION(4,3) || (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64))
|
|
1118
1268
|
#if ECB_GCC_VERSION(4,8) || ECB_CLANG_BUILTIN(__builtin_bswap16)
|
|
1119
1269
|
#define ecb_bswap16(x) __builtin_bswap16 (x)
|
|
@@ -1194,6 +1344,78 @@ ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_he
|
|
|
1194
1344
|
ecb_inline ecb_const ecb_bool ecb_little_endian (void);
|
|
1195
1345
|
ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; }
|
|
1196
1346
|
|
|
1347
|
+
/*****************************************************************************/
|
|
1348
|
+
/* unaligned load/store */
|
|
1349
|
+
|
|
1350
|
+
ecb_inline uint_fast16_t ecb_be_u16_to_host (uint_fast16_t v) { return ecb_little_endian () ? ecb_bswap16 (v) : v; }
|
|
1351
|
+
ecb_inline uint_fast32_t ecb_be_u32_to_host (uint_fast32_t v) { return ecb_little_endian () ? ecb_bswap32 (v) : v; }
|
|
1352
|
+
ecb_inline uint_fast64_t ecb_be_u64_to_host (uint_fast64_t v) { return ecb_little_endian () ? ecb_bswap64 (v) : v; }
|
|
1353
|
+
|
|
1354
|
+
ecb_inline uint_fast16_t ecb_le_u16_to_host (uint_fast16_t v) { return ecb_big_endian () ? ecb_bswap16 (v) : v; }
|
|
1355
|
+
ecb_inline uint_fast32_t ecb_le_u32_to_host (uint_fast32_t v) { return ecb_big_endian () ? ecb_bswap32 (v) : v; }
|
|
1356
|
+
ecb_inline uint_fast64_t ecb_le_u64_to_host (uint_fast64_t v) { return ecb_big_endian () ? ecb_bswap64 (v) : v; }
|
|
1357
|
+
|
|
1358
|
+
ecb_inline uint_fast16_t ecb_peek_u16_u (const void *ptr) { uint16_t v; memcpy (&v, ptr, sizeof (v)); return v; }
|
|
1359
|
+
ecb_inline uint_fast32_t ecb_peek_u32_u (const void *ptr) { uint32_t v; memcpy (&v, ptr, sizeof (v)); return v; }
|
|
1360
|
+
ecb_inline uint_fast64_t ecb_peek_u64_u (const void *ptr) { uint64_t v; memcpy (&v, ptr, sizeof (v)); return v; }
|
|
1361
|
+
|
|
1362
|
+
ecb_inline uint_fast16_t ecb_peek_be_u16_u (const void *ptr) { return ecb_be_u16_to_host (ecb_peek_u16_u (ptr)); }
|
|
1363
|
+
ecb_inline uint_fast32_t ecb_peek_be_u32_u (const void *ptr) { return ecb_be_u32_to_host (ecb_peek_u32_u (ptr)); }
|
|
1364
|
+
ecb_inline uint_fast64_t ecb_peek_be_u64_u (const void *ptr) { return ecb_be_u64_to_host (ecb_peek_u64_u (ptr)); }
|
|
1365
|
+
|
|
1366
|
+
ecb_inline uint_fast16_t ecb_peek_le_u16_u (const void *ptr) { return ecb_le_u16_to_host (ecb_peek_u16_u (ptr)); }
|
|
1367
|
+
ecb_inline uint_fast32_t ecb_peek_le_u32_u (const void *ptr) { return ecb_le_u32_to_host (ecb_peek_u32_u (ptr)); }
|
|
1368
|
+
ecb_inline uint_fast64_t ecb_peek_le_u64_u (const void *ptr) { return ecb_le_u64_to_host (ecb_peek_u64_u (ptr)); }
|
|
1369
|
+
|
|
1370
|
+
ecb_inline uint_fast16_t ecb_host_to_be_u16 (uint_fast16_t v) { return ecb_little_endian () ? ecb_bswap16 (v) : v; }
|
|
1371
|
+
ecb_inline uint_fast32_t ecb_host_to_be_u32 (uint_fast32_t v) { return ecb_little_endian () ? ecb_bswap32 (v) : v; }
|
|
1372
|
+
ecb_inline uint_fast64_t ecb_host_to_be_u64 (uint_fast64_t v) { return ecb_little_endian () ? ecb_bswap64 (v) : v; }
|
|
1373
|
+
|
|
1374
|
+
ecb_inline uint_fast16_t ecb_host_to_le_u16 (uint_fast16_t v) { return ecb_big_endian () ? ecb_bswap16 (v) : v; }
|
|
1375
|
+
ecb_inline uint_fast32_t ecb_host_to_le_u32 (uint_fast32_t v) { return ecb_big_endian () ? ecb_bswap32 (v) : v; }
|
|
1376
|
+
ecb_inline uint_fast64_t ecb_host_to_le_u64 (uint_fast64_t v) { return ecb_big_endian () ? ecb_bswap64 (v) : v; }
|
|
1377
|
+
|
|
1378
|
+
ecb_inline void ecb_poke_u16_u (void *ptr, uint16_t v) { memcpy (ptr, &v, sizeof (v)); }
|
|
1379
|
+
ecb_inline void ecb_poke_u32_u (void *ptr, uint32_t v) { memcpy (ptr, &v, sizeof (v)); }
|
|
1380
|
+
ecb_inline void ecb_poke_u64_u (void *ptr, uint64_t v) { memcpy (ptr, &v, sizeof (v)); }
|
|
1381
|
+
|
|
1382
|
+
ecb_inline void ecb_poke_be_u16_u (void *ptr, uint_fast16_t v) { ecb_poke_u16_u (ptr, ecb_host_to_be_u16 (v)); }
|
|
1383
|
+
ecb_inline void ecb_poke_be_u32_u (void *ptr, uint_fast32_t v) { ecb_poke_u32_u (ptr, ecb_host_to_be_u32 (v)); }
|
|
1384
|
+
ecb_inline void ecb_poke_be_u64_u (void *ptr, uint_fast64_t v) { ecb_poke_u64_u (ptr, ecb_host_to_be_u64 (v)); }
|
|
1385
|
+
|
|
1386
|
+
ecb_inline void ecb_poke_le_u16_u (void *ptr, uint_fast16_t v) { ecb_poke_u16_u (ptr, ecb_host_to_le_u16 (v)); }
|
|
1387
|
+
ecb_inline void ecb_poke_le_u32_u (void *ptr, uint_fast32_t v) { ecb_poke_u32_u (ptr, ecb_host_to_le_u32 (v)); }
|
|
1388
|
+
ecb_inline void ecb_poke_le_u64_u (void *ptr, uint_fast64_t v) { ecb_poke_u64_u (ptr, ecb_host_to_le_u64 (v)); }
|
|
1389
|
+
|
|
1390
|
+
#if ECB_CPP
|
|
1391
|
+
|
|
1392
|
+
inline uint8_t ecb_bswap (uint8_t v) { return v; }
|
|
1393
|
+
inline uint16_t ecb_bswap (uint16_t v) { return ecb_bswap16 (v); }
|
|
1394
|
+
inline uint32_t ecb_bswap (uint32_t v) { return ecb_bswap32 (v); }
|
|
1395
|
+
inline uint64_t ecb_bswap (uint64_t v) { return ecb_bswap64 (v); }
|
|
1396
|
+
|
|
1397
|
+
template<typename T> inline T ecb_be_to_host (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; }
|
|
1398
|
+
template<typename T> inline T ecb_le_to_host (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; }
|
|
1399
|
+
template<typename T> inline T ecb_peek (const void *ptr) { return *(const T *)ptr; }
|
|
1400
|
+
template<typename T> inline T ecb_peek_be (const void *ptr) { return ecb_be_to_host (ecb_peek <T> (ptr)); }
|
|
1401
|
+
template<typename T> inline T ecb_peek_le (const void *ptr) { return ecb_le_to_host (ecb_peek <T> (ptr)); }
|
|
1402
|
+
template<typename T> inline T ecb_peek_u (const void *ptr) { T v; memcpy (&v, ptr, sizeof (v)); return v; }
|
|
1403
|
+
template<typename T> inline T ecb_peek_be_u (const void *ptr) { return ecb_be_to_host (ecb_peek_u<T> (ptr)); }
|
|
1404
|
+
template<typename T> inline T ecb_peek_le_u (const void *ptr) { return ecb_le_to_host (ecb_peek_u<T> (ptr)); }
|
|
1405
|
+
|
|
1406
|
+
template<typename T> inline T ecb_host_to_be (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; }
|
|
1407
|
+
template<typename T> inline T ecb_host_to_le (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; }
|
|
1408
|
+
template<typename T> inline void ecb_poke (void *ptr, T v) { *(T *)ptr = v; }
|
|
1409
|
+
template<typename T> inline void ecb_poke_be (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_be (v)); }
|
|
1410
|
+
template<typename T> inline void ecb_poke_le (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_le (v)); }
|
|
1411
|
+
template<typename T> inline void ecb_poke_u (void *ptr, T v) { memcpy (ptr, &v, sizeof (v)); }
|
|
1412
|
+
template<typename T> inline void ecb_poke_be_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_be (v)); }
|
|
1413
|
+
template<typename T> inline void ecb_poke_le_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_le (v)); }
|
|
1414
|
+
|
|
1415
|
+
#endif
|
|
1416
|
+
|
|
1417
|
+
/*****************************************************************************/
|
|
1418
|
+
|
|
1197
1419
|
#if ECB_GCC_VERSION(3,0) || ECB_C99
|
|
1198
1420
|
#define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
|
|
1199
1421
|
#else
|
|
@@ -1227,6 +1449,8 @@ ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_he
|
|
|
1227
1449
|
#define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
|
|
1228
1450
|
#endif
|
|
1229
1451
|
|
|
1452
|
+
/*****************************************************************************/
|
|
1453
|
+
|
|
1230
1454
|
ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);
|
|
1231
1455
|
ecb_function_ ecb_const uint32_t
|
|
1232
1456
|
ecb_binary16_to_binary32 (uint32_t x)
|
|
@@ -1344,7 +1568,6 @@ ecb_binary32_to_binary16 (uint32_t x)
|
|
|
1344
1568
|
|| (defined __arm__ && (defined __ARM_EABI__ || defined __EABI__ || defined __VFP_FP__ || defined _WIN32_WCE || defined __ANDROID__)) \
|
|
1345
1569
|
|| defined __aarch64__
|
|
1346
1570
|
#define ECB_STDFP 1
|
|
1347
|
-
#include <string.h> /* for memcpy */
|
|
1348
1571
|
#else
|
|
1349
1572
|
#define ECB_STDFP 0
|
|
1350
1573
|
#endif
|
|
@@ -1539,7 +1762,7 @@ ecb_binary32_to_binary16 (uint32_t x)
|
|
|
1539
1762
|
#if ECB_MEMORY_FENCE_NEEDS_PTHREADS
|
|
1540
1763
|
/* if your architecture doesn't need memory fences, e.g. because it is
|
|
1541
1764
|
* single-cpu/core, or if you use libev in a project that doesn't use libev
|
|
1542
|
-
* from multiple threads, then you can define
|
|
1765
|
+
* from multiple threads, then you can define ECB_NO_THREADS when compiling
|
|
1543
1766
|
* libev, in which cases the memory fences become nops.
|
|
1544
1767
|
* alternatively, you can remove this #error and link against libpthread,
|
|
1545
1768
|
* which will then provide the memory fences.
|
|
@@ -1553,18 +1776,80 @@ ecb_binary32_to_binary16 (uint32_t x)
|
|
|
1553
1776
|
# define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
|
|
1554
1777
|
#endif
|
|
1555
1778
|
|
|
1556
|
-
#define expect_false(cond) ecb_expect_false (cond)
|
|
1557
|
-
#define expect_true(cond) ecb_expect_true (cond)
|
|
1558
|
-
#define noinline ecb_noinline
|
|
1559
|
-
|
|
1560
1779
|
#define inline_size ecb_inline
|
|
1561
1780
|
|
|
1562
1781
|
#if EV_FEATURE_CODE
|
|
1563
1782
|
# define inline_speed ecb_inline
|
|
1564
1783
|
#else
|
|
1565
|
-
# define inline_speed
|
|
1784
|
+
# define inline_speed ecb_noinline static
|
|
1566
1785
|
#endif
|
|
1567
1786
|
|
|
1787
|
+
/*****************************************************************************/
|
|
1788
|
+
/* raw syscall wrappers */
|
|
1789
|
+
|
|
1790
|
+
#if EV_NEED_SYSCALL
|
|
1791
|
+
|
|
1792
|
+
#include <sys/syscall.h>
|
|
1793
|
+
|
|
1794
|
+
/*
|
|
1795
|
+
* define some syscall wrappers for common architectures
|
|
1796
|
+
* this is mostly for nice looks during debugging, not performance.
|
|
1797
|
+
* our syscalls return < 0, not == -1, on error. which is good
|
|
1798
|
+
* enough for linux aio.
|
|
1799
|
+
* TODO: arm is also common nowadays, maybe even mips and x86
|
|
1800
|
+
* TODO: after implementing this, it suddenly looks like overkill, but its hard to remove...
|
|
1801
|
+
*/
|
|
1802
|
+
#if __GNUC__ && __linux && ECB_AMD64 && !EV_FEATURE_CODE
|
|
1803
|
+
/* the costly errno access probably kills this for size optimisation */
|
|
1804
|
+
|
|
1805
|
+
#define ev_syscall(nr,narg,arg1,arg2,arg3,arg4,arg5,arg6) \
|
|
1806
|
+
({ \
|
|
1807
|
+
long res; \
|
|
1808
|
+
register unsigned long r6 __asm__ ("r9" ); \
|
|
1809
|
+
register unsigned long r5 __asm__ ("r8" ); \
|
|
1810
|
+
register unsigned long r4 __asm__ ("r10"); \
|
|
1811
|
+
register unsigned long r3 __asm__ ("rdx"); \
|
|
1812
|
+
register unsigned long r2 __asm__ ("rsi"); \
|
|
1813
|
+
register unsigned long r1 __asm__ ("rdi"); \
|
|
1814
|
+
if (narg >= 6) r6 = (unsigned long)(arg6); \
|
|
1815
|
+
if (narg >= 5) r5 = (unsigned long)(arg5); \
|
|
1816
|
+
if (narg >= 4) r4 = (unsigned long)(arg4); \
|
|
1817
|
+
if (narg >= 3) r3 = (unsigned long)(arg3); \
|
|
1818
|
+
if (narg >= 2) r2 = (unsigned long)(arg2); \
|
|
1819
|
+
if (narg >= 1) r1 = (unsigned long)(arg1); \
|
|
1820
|
+
__asm__ __volatile__ ( \
|
|
1821
|
+
"syscall\n\t" \
|
|
1822
|
+
: "=a" (res) \
|
|
1823
|
+
: "0" (nr), "r" (r1), "r" (r2), "r" (r3), "r" (r4), "r" (r5) \
|
|
1824
|
+
: "cc", "r11", "cx", "memory"); \
|
|
1825
|
+
errno = -res; \
|
|
1826
|
+
res; \
|
|
1827
|
+
})
|
|
1828
|
+
|
|
1829
|
+
#endif
|
|
1830
|
+
|
|
1831
|
+
#ifdef ev_syscall
|
|
1832
|
+
#define ev_syscall0(nr) ev_syscall (nr, 0, 0, 0, 0, 0, 0, 0)
|
|
1833
|
+
#define ev_syscall1(nr,arg1) ev_syscall (nr, 1, arg1, 0, 0, 0, 0, 0)
|
|
1834
|
+
#define ev_syscall2(nr,arg1,arg2) ev_syscall (nr, 2, arg1, arg2, 0, 0, 0, 0)
|
|
1835
|
+
#define ev_syscall3(nr,arg1,arg2,arg3) ev_syscall (nr, 3, arg1, arg2, arg3, 0, 0, 0)
|
|
1836
|
+
#define ev_syscall4(nr,arg1,arg2,arg3,arg4) ev_syscall (nr, 3, arg1, arg2, arg3, arg4, 0, 0)
|
|
1837
|
+
#define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) ev_syscall (nr, 5, arg1, arg2, arg3, arg4, arg5, 0)
|
|
1838
|
+
#define ev_syscall6(nr,arg1,arg2,arg3,arg4,arg5,arg6) ev_syscall (nr, 6, arg1, arg2, arg3, arg4, arg5,arg6)
|
|
1839
|
+
#else
|
|
1840
|
+
#define ev_syscall0(nr) syscall (nr)
|
|
1841
|
+
#define ev_syscall1(nr,arg1) syscall (nr, arg1)
|
|
1842
|
+
#define ev_syscall2(nr,arg1,arg2) syscall (nr, arg1, arg2)
|
|
1843
|
+
#define ev_syscall3(nr,arg1,arg2,arg3) syscall (nr, arg1, arg2, arg3)
|
|
1844
|
+
#define ev_syscall4(nr,arg1,arg2,arg3,arg4) syscall (nr, arg1, arg2, arg3, arg4)
|
|
1845
|
+
#define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) syscall (nr, arg1, arg2, arg3, arg4, arg5)
|
|
1846
|
+
#define ev_syscall6(nr,arg1,arg2,arg3,arg4,arg5,arg6) syscall (nr, arg1, arg2, arg3, arg4, arg5,arg6)
|
|
1847
|
+
#endif
|
|
1848
|
+
|
|
1849
|
+
#endif
|
|
1850
|
+
|
|
1851
|
+
/*****************************************************************************/
|
|
1852
|
+
|
|
1568
1853
|
#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
|
|
1569
1854
|
|
|
1570
1855
|
#if EV_MINPRI == EV_MAXPRI
|
|
@@ -1622,7 +1907,7 @@ static EV_ATOMIC_T have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work?
|
|
|
1622
1907
|
#include <float.h>
|
|
1623
1908
|
|
|
1624
1909
|
/* a floor() replacement function, should be independent of ev_tstamp type */
|
|
1625
|
-
|
|
1910
|
+
ecb_noinline
|
|
1626
1911
|
static ev_tstamp
|
|
1627
1912
|
ev_floor (ev_tstamp v)
|
|
1628
1913
|
{
|
|
@@ -1633,26 +1918,26 @@ ev_floor (ev_tstamp v)
|
|
|
1633
1918
|
const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;
|
|
1634
1919
|
#endif
|
|
1635
1920
|
|
|
1636
|
-
/*
|
|
1637
|
-
if (
|
|
1921
|
+
/* special treatment for negative arguments */
|
|
1922
|
+
if (ecb_expect_false (v < 0.))
|
|
1923
|
+
{
|
|
1924
|
+
ev_tstamp f = -ev_floor (-v);
|
|
1925
|
+
|
|
1926
|
+
return f - (f == v ? 0 : 1);
|
|
1927
|
+
}
|
|
1928
|
+
|
|
1929
|
+
/* argument too large for an unsigned long? then reduce it */
|
|
1930
|
+
if (ecb_expect_false (v >= shift))
|
|
1638
1931
|
{
|
|
1639
1932
|
ev_tstamp f;
|
|
1640
1933
|
|
|
1641
1934
|
if (v == v - 1.)
|
|
1642
|
-
return v; /* very large
|
|
1935
|
+
return v; /* very large numbers are assumed to be integer */
|
|
1643
1936
|
|
|
1644
1937
|
f = shift * ev_floor (v * (1. / shift));
|
|
1645
1938
|
return f + ev_floor (v - f);
|
|
1646
1939
|
}
|
|
1647
1940
|
|
|
1648
|
-
/* special treatment for negative args? */
|
|
1649
|
-
if (expect_false (v < 0.))
|
|
1650
|
-
{
|
|
1651
|
-
ev_tstamp f = -ev_floor (-v);
|
|
1652
|
-
|
|
1653
|
-
return f - (f == v ? 0 : 1);
|
|
1654
|
-
}
|
|
1655
|
-
|
|
1656
1941
|
/* fits into an unsigned long */
|
|
1657
1942
|
return (unsigned long)v;
|
|
1658
1943
|
}
|
|
@@ -1665,7 +1950,7 @@ ev_floor (ev_tstamp v)
|
|
|
1665
1950
|
# include <sys/utsname.h>
|
|
1666
1951
|
#endif
|
|
1667
1952
|
|
|
1668
|
-
|
|
1953
|
+
ecb_noinline ecb_cold
|
|
1669
1954
|
static unsigned int
|
|
1670
1955
|
ev_linux_version (void)
|
|
1671
1956
|
{
|
|
@@ -1705,7 +1990,7 @@ ev_linux_version (void)
|
|
|
1705
1990
|
/*****************************************************************************/
|
|
1706
1991
|
|
|
1707
1992
|
#if EV_AVOID_STDIO
|
|
1708
|
-
|
|
1993
|
+
ecb_noinline ecb_cold
|
|
1709
1994
|
static void
|
|
1710
1995
|
ev_printerr (const char *msg)
|
|
1711
1996
|
{
|
|
@@ -1722,7 +2007,7 @@ ev_set_syserr_cb (void (*cb)(const char *msg) EV_NOEXCEPT) EV_NOEXCEPT
|
|
|
1722
2007
|
syserr_cb = cb;
|
|
1723
2008
|
}
|
|
1724
2009
|
|
|
1725
|
-
|
|
2010
|
+
ecb_noinline ecb_cold
|
|
1726
2011
|
static void
|
|
1727
2012
|
ev_syserr (const char *msg)
|
|
1728
2013
|
{
|
|
@@ -1804,7 +2089,7 @@ typedef struct
|
|
|
1804
2089
|
unsigned char events; /* the events watched for */
|
|
1805
2090
|
unsigned char reify; /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */
|
|
1806
2091
|
unsigned char emask; /* some backends store the actual kernel mask in here */
|
|
1807
|
-
unsigned char
|
|
2092
|
+
unsigned char eflags; /* flags field for use by backends */
|
|
1808
2093
|
#if EV_USE_EPOLL
|
|
1809
2094
|
unsigned int egen; /* generation counter to counter epoll bugs */
|
|
1810
2095
|
#endif
|
|
@@ -1868,7 +2153,7 @@ typedef struct
|
|
|
1868
2153
|
|
|
1869
2154
|
#else
|
|
1870
2155
|
|
|
1871
|
-
EV_API_DECL ev_tstamp ev_rt_now = 0; /* needs to be initialised to make it a definition despite extern */
|
|
2156
|
+
EV_API_DECL ev_tstamp ev_rt_now = EV_TS_CONST (0.); /* needs to be initialised to make it a definition despite extern */
|
|
1872
2157
|
#define VAR(name,decl) static decl;
|
|
1873
2158
|
#include "ev_vars.h"
|
|
1874
2159
|
#undef VAR
|
|
@@ -1878,8 +2163,8 @@ typedef struct
|
|
|
1878
2163
|
#endif
|
|
1879
2164
|
|
|
1880
2165
|
#if EV_FEATURE_API
|
|
1881
|
-
# define EV_RELEASE_CB if (
|
|
1882
|
-
# define EV_ACQUIRE_CB if (
|
|
2166
|
+
# define EV_RELEASE_CB if (ecb_expect_false (release_cb)) release_cb (EV_A)
|
|
2167
|
+
# define EV_ACQUIRE_CB if (ecb_expect_false (acquire_cb)) acquire_cb (EV_A)
|
|
1883
2168
|
# define EV_INVOKE_PENDING invoke_cb (EV_A)
|
|
1884
2169
|
#else
|
|
1885
2170
|
# define EV_RELEASE_CB (void)0
|
|
@@ -1896,17 +2181,19 @@ ev_tstamp
|
|
|
1896
2181
|
ev_time (void) EV_NOEXCEPT
|
|
1897
2182
|
{
|
|
1898
2183
|
#if EV_USE_REALTIME
|
|
1899
|
-
if (
|
|
2184
|
+
if (ecb_expect_true (have_realtime))
|
|
1900
2185
|
{
|
|
1901
2186
|
struct timespec ts;
|
|
1902
2187
|
clock_gettime (CLOCK_REALTIME, &ts);
|
|
1903
|
-
return
|
|
2188
|
+
return EV_TS_GET (ts);
|
|
1904
2189
|
}
|
|
1905
2190
|
#endif
|
|
1906
2191
|
|
|
1907
|
-
|
|
1908
|
-
|
|
1909
|
-
|
|
2192
|
+
{
|
|
2193
|
+
struct timeval tv;
|
|
2194
|
+
gettimeofday (&tv, 0);
|
|
2195
|
+
return EV_TV_GET (tv);
|
|
2196
|
+
}
|
|
1910
2197
|
}
|
|
1911
2198
|
#endif
|
|
1912
2199
|
|
|
@@ -1914,11 +2201,11 @@ inline_size ev_tstamp
|
|
|
1914
2201
|
get_clock (void)
|
|
1915
2202
|
{
|
|
1916
2203
|
#if EV_USE_MONOTONIC
|
|
1917
|
-
if (
|
|
2204
|
+
if (ecb_expect_true (have_monotonic))
|
|
1918
2205
|
{
|
|
1919
2206
|
struct timespec ts;
|
|
1920
2207
|
clock_gettime (CLOCK_MONOTONIC, &ts);
|
|
1921
|
-
return
|
|
2208
|
+
return EV_TS_GET (ts);
|
|
1922
2209
|
}
|
|
1923
2210
|
#endif
|
|
1924
2211
|
|
|
@@ -1936,7 +2223,7 @@ ev_now (EV_P) EV_NOEXCEPT
|
|
|
1936
2223
|
void
|
|
1937
2224
|
ev_sleep (ev_tstamp delay) EV_NOEXCEPT
|
|
1938
2225
|
{
|
|
1939
|
-
if (delay > 0.)
|
|
2226
|
+
if (delay > EV_TS_CONST (0.))
|
|
1940
2227
|
{
|
|
1941
2228
|
#if EV_USE_NANOSLEEP
|
|
1942
2229
|
struct timespec ts;
|
|
@@ -1946,7 +2233,7 @@ ev_sleep (ev_tstamp delay) EV_NOEXCEPT
|
|
|
1946
2233
|
#elif defined _WIN32
|
|
1947
2234
|
/* maybe this should round up, as ms is very low resolution */
|
|
1948
2235
|
/* compared to select (µs) or nanosleep (ns) */
|
|
1949
|
-
Sleep ((unsigned long)(delay
|
|
2236
|
+
Sleep ((unsigned long)(EV_TS_TO_MSEC (delay)));
|
|
1950
2237
|
#else
|
|
1951
2238
|
struct timeval tv;
|
|
1952
2239
|
|
|
@@ -1986,7 +2273,7 @@ array_nextsize (int elem, int cur, int cnt)
|
|
|
1986
2273
|
return ncur;
|
|
1987
2274
|
}
|
|
1988
2275
|
|
|
1989
|
-
|
|
2276
|
+
ecb_noinline ecb_cold
|
|
1990
2277
|
static void *
|
|
1991
2278
|
array_realloc (int elem, void *base, int *cur, int cnt)
|
|
1992
2279
|
{
|
|
@@ -2000,7 +2287,7 @@ array_realloc (int elem, void *base, int *cur, int cnt)
|
|
|
2000
2287
|
memset ((void *)(base + offset), 0, sizeof (*(base)) * (count))
|
|
2001
2288
|
|
|
2002
2289
|
#define array_needsize(type,base,cur,cnt,init) \
|
|
2003
|
-
if (
|
|
2290
|
+
if (ecb_expect_false ((cnt) > (cur))) \
|
|
2004
2291
|
{ \
|
|
2005
2292
|
ecb_unused int ocur_ = (cur); \
|
|
2006
2293
|
(base) = (type *)array_realloc \
|
|
@@ -2024,20 +2311,20 @@ array_realloc (int elem, void *base, int *cur, int cnt)
|
|
|
2024
2311
|
/*****************************************************************************/
|
|
2025
2312
|
|
|
2026
2313
|
/* dummy callback for pending events */
|
|
2027
|
-
|
|
2314
|
+
ecb_noinline
|
|
2028
2315
|
static void
|
|
2029
2316
|
pendingcb (EV_P_ ev_prepare *w, int revents)
|
|
2030
2317
|
{
|
|
2031
2318
|
}
|
|
2032
2319
|
|
|
2033
|
-
|
|
2320
|
+
ecb_noinline
|
|
2034
2321
|
void
|
|
2035
2322
|
ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT
|
|
2036
2323
|
{
|
|
2037
2324
|
W w_ = (W)w;
|
|
2038
2325
|
int pri = ABSPRI (w_);
|
|
2039
2326
|
|
|
2040
|
-
if (
|
|
2327
|
+
if (ecb_expect_false (w_->pending))
|
|
2041
2328
|
pendings [pri][w_->pending - 1].events |= revents;
|
|
2042
2329
|
else
|
|
2043
2330
|
{
|
|
@@ -2098,7 +2385,7 @@ fd_event (EV_P_ int fd, int revents)
|
|
|
2098
2385
|
{
|
|
2099
2386
|
ANFD *anfd = anfds + fd;
|
|
2100
2387
|
|
|
2101
|
-
if (
|
|
2388
|
+
if (ecb_expect_true (!anfd->reify))
|
|
2102
2389
|
fd_event_nocheck (EV_A_ fd, revents);
|
|
2103
2390
|
}
|
|
2104
2391
|
|
|
@@ -2116,8 +2403,20 @@ fd_reify (EV_P)
|
|
|
2116
2403
|
{
|
|
2117
2404
|
int i;
|
|
2118
2405
|
|
|
2406
|
+
/* most backends do not modify the fdchanges list in backend_modfiy.
|
|
2407
|
+
* except io_uring, which has fixed-size buffers which might force us
|
|
2408
|
+
* to handle events in backend_modify, causing fdchanges to be amended,
|
|
2409
|
+
* which could result in an endless loop.
|
|
2410
|
+
* to avoid this, we do not dynamically handle fds that were added
|
|
2411
|
+
* during fd_reify. that means that for those backends, fdchangecnt
|
|
2412
|
+
* might be non-zero during poll, which must cause them to not block.
|
|
2413
|
+
* to not put too much of a burden on other backends, this detail
|
|
2414
|
+
* needs to be handled in the backend.
|
|
2415
|
+
*/
|
|
2416
|
+
int changecnt = fdchangecnt;
|
|
2417
|
+
|
|
2119
2418
|
#if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
|
|
2120
|
-
for (i = 0; i <
|
|
2419
|
+
for (i = 0; i < changecnt; ++i)
|
|
2121
2420
|
{
|
|
2122
2421
|
int fd = fdchanges [i];
|
|
2123
2422
|
ANFD *anfd = anfds + fd;
|
|
@@ -2141,7 +2440,7 @@ fd_reify (EV_P)
|
|
|
2141
2440
|
}
|
|
2142
2441
|
#endif
|
|
2143
2442
|
|
|
2144
|
-
for (i = 0; i <
|
|
2443
|
+
for (i = 0; i < changecnt; ++i)
|
|
2145
2444
|
{
|
|
2146
2445
|
int fd = fdchanges [i];
|
|
2147
2446
|
ANFD *anfd = anfds + fd;
|
|
@@ -2152,7 +2451,7 @@ fd_reify (EV_P)
|
|
|
2152
2451
|
|
|
2153
2452
|
anfd->reify = 0;
|
|
2154
2453
|
|
|
2155
|
-
/*if (
|
|
2454
|
+
/*if (ecb_expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */
|
|
2156
2455
|
{
|
|
2157
2456
|
anfd->events = 0;
|
|
2158
2457
|
|
|
@@ -2167,7 +2466,14 @@ fd_reify (EV_P)
|
|
|
2167
2466
|
backend_modify (EV_A_ fd, o_events, anfd->events);
|
|
2168
2467
|
}
|
|
2169
2468
|
|
|
2170
|
-
fdchangecnt
|
|
2469
|
+
/* normally, fdchangecnt hasn't changed. if it has, then new fds have been added.
|
|
2470
|
+
* this is a rare case (see beginning comment in this function), so we copy them to the
|
|
2471
|
+
* front and hope the backend handles this case.
|
|
2472
|
+
*/
|
|
2473
|
+
if (ecb_expect_false (fdchangecnt != changecnt))
|
|
2474
|
+
memmove (fdchanges, fdchanges + changecnt, (fdchangecnt - changecnt) * sizeof (*fdchanges));
|
|
2475
|
+
|
|
2476
|
+
fdchangecnt -= changecnt;
|
|
2171
2477
|
}
|
|
2172
2478
|
|
|
2173
2479
|
/* something about the given fd changed */
|
|
@@ -2176,9 +2482,9 @@ void
|
|
|
2176
2482
|
fd_change (EV_P_ int fd, int flags)
|
|
2177
2483
|
{
|
|
2178
2484
|
unsigned char reify = anfds [fd].reify;
|
|
2179
|
-
anfds [fd].reify
|
|
2485
|
+
anfds [fd].reify = reify | flags;
|
|
2180
2486
|
|
|
2181
|
-
if (
|
|
2487
|
+
if (ecb_expect_true (!reify))
|
|
2182
2488
|
{
|
|
2183
2489
|
++fdchangecnt;
|
|
2184
2490
|
array_needsize (int, fdchanges, fdchangemax, fdchangecnt, array_needsize_noinit);
|
|
@@ -2211,7 +2517,7 @@ fd_valid (int fd)
|
|
|
2211
2517
|
}
|
|
2212
2518
|
|
|
2213
2519
|
/* called on EBADF to verify fds */
|
|
2214
|
-
|
|
2520
|
+
ecb_noinline ecb_cold
|
|
2215
2521
|
static void
|
|
2216
2522
|
fd_ebadf (EV_P)
|
|
2217
2523
|
{
|
|
@@ -2224,7 +2530,7 @@ fd_ebadf (EV_P)
|
|
|
2224
2530
|
}
|
|
2225
2531
|
|
|
2226
2532
|
/* called on ENOMEM in select/poll to kill some fds and retry */
|
|
2227
|
-
|
|
2533
|
+
ecb_noinline ecb_cold
|
|
2228
2534
|
static void
|
|
2229
2535
|
fd_enomem (EV_P)
|
|
2230
2536
|
{
|
|
@@ -2239,7 +2545,7 @@ fd_enomem (EV_P)
|
|
|
2239
2545
|
}
|
|
2240
2546
|
|
|
2241
2547
|
/* usually called after fork if backend needs to re-arm all fds from scratch */
|
|
2242
|
-
|
|
2548
|
+
ecb_noinline
|
|
2243
2549
|
static void
|
|
2244
2550
|
fd_rearm_all (EV_P)
|
|
2245
2551
|
{
|
|
@@ -2303,19 +2609,19 @@ downheap (ANHE *heap, int N, int k)
|
|
|
2303
2609
|
ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;
|
|
2304
2610
|
|
|
2305
2611
|
/* find minimum child */
|
|
2306
|
-
if (
|
|
2612
|
+
if (ecb_expect_true (pos + DHEAP - 1 < E))
|
|
2307
2613
|
{
|
|
2308
2614
|
/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
|
|
2309
|
-
if ( ANHE_at (pos [1])
|
|
2310
|
-
if ( ANHE_at (pos [2])
|
|
2311
|
-
if ( ANHE_at (pos [3])
|
|
2615
|
+
if ( minat > ANHE_at (pos [1])) (minpos = pos + 1), (minat = ANHE_at (*minpos));
|
|
2616
|
+
if ( minat > ANHE_at (pos [2])) (minpos = pos + 2), (minat = ANHE_at (*minpos));
|
|
2617
|
+
if ( minat > ANHE_at (pos [3])) (minpos = pos + 3), (minat = ANHE_at (*minpos));
|
|
2312
2618
|
}
|
|
2313
2619
|
else if (pos < E)
|
|
2314
2620
|
{
|
|
2315
2621
|
/* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
|
|
2316
|
-
if (pos + 1 < E && ANHE_at (pos [1])
|
|
2317
|
-
if (pos + 2 < E && ANHE_at (pos [2])
|
|
2318
|
-
if (pos + 3 < E && ANHE_at (pos [3])
|
|
2622
|
+
if (pos + 1 < E && minat > ANHE_at (pos [1])) (minpos = pos + 1), (minat = ANHE_at (*minpos));
|
|
2623
|
+
if (pos + 2 < E && minat > ANHE_at (pos [2])) (minpos = pos + 2), (minat = ANHE_at (*minpos));
|
|
2624
|
+
if (pos + 3 < E && minat > ANHE_at (pos [3])) (minpos = pos + 3), (minat = ANHE_at (*minpos));
|
|
2319
2625
|
}
|
|
2320
2626
|
else
|
|
2321
2627
|
break;
|
|
@@ -2333,7 +2639,7 @@ downheap (ANHE *heap, int N, int k)
|
|
|
2333
2639
|
ev_active (ANHE_w (he)) = k;
|
|
2334
2640
|
}
|
|
2335
2641
|
|
|
2336
|
-
#else /* 4HEAP */
|
|
2642
|
+
#else /* not 4HEAP */
|
|
2337
2643
|
|
|
2338
2644
|
#define HEAP0 1
|
|
2339
2645
|
#define HPARENT(k) ((k) >> 1)
|
|
@@ -2360,7 +2666,7 @@ downheap (ANHE *heap, int N, int k)
|
|
|
2360
2666
|
|
|
2361
2667
|
heap [k] = heap [c];
|
|
2362
2668
|
ev_active (ANHE_w (heap [k])) = k;
|
|
2363
|
-
|
|
2669
|
+
|
|
2364
2670
|
k = c;
|
|
2365
2671
|
}
|
|
2366
2672
|
|
|
@@ -2415,7 +2721,7 @@ reheap (ANHE *heap, int N)
|
|
|
2415
2721
|
|
|
2416
2722
|
/*****************************************************************************/
|
|
2417
2723
|
|
|
2418
|
-
/* associate signal watchers to a signal
|
|
2724
|
+
/* associate signal watchers to a signal */
|
|
2419
2725
|
typedef struct
|
|
2420
2726
|
{
|
|
2421
2727
|
EV_ATOMIC_T pending;
|
|
@@ -2431,7 +2737,7 @@ static ANSIG signals [EV_NSIG - 1];
|
|
|
2431
2737
|
|
|
2432
2738
|
#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
|
|
2433
2739
|
|
|
2434
|
-
|
|
2740
|
+
ecb_noinline ecb_cold
|
|
2435
2741
|
static void
|
|
2436
2742
|
evpipe_init (EV_P)
|
|
2437
2743
|
{
|
|
@@ -2482,7 +2788,7 @@ evpipe_write (EV_P_ EV_ATOMIC_T *flag)
|
|
|
2482
2788
|
{
|
|
2483
2789
|
ECB_MEMORY_FENCE; /* push out the write before this function was called, acquire flag */
|
|
2484
2790
|
|
|
2485
|
-
if (
|
|
2791
|
+
if (ecb_expect_true (*flag))
|
|
2486
2792
|
return;
|
|
2487
2793
|
|
|
2488
2794
|
*flag = 1;
|
|
@@ -2569,7 +2875,7 @@ pipecb (EV_P_ ev_io *iow, int revents)
|
|
|
2569
2875
|
ECB_MEMORY_FENCE;
|
|
2570
2876
|
|
|
2571
2877
|
for (i = EV_NSIG - 1; i--; )
|
|
2572
|
-
if (
|
|
2878
|
+
if (ecb_expect_false (signals [i].pending))
|
|
2573
2879
|
ev_feed_signal_event (EV_A_ i + 1);
|
|
2574
2880
|
}
|
|
2575
2881
|
#endif
|
|
@@ -2620,13 +2926,13 @@ ev_sighandler (int signum)
|
|
|
2620
2926
|
ev_feed_signal (signum);
|
|
2621
2927
|
}
|
|
2622
2928
|
|
|
2623
|
-
|
|
2929
|
+
ecb_noinline
|
|
2624
2930
|
void
|
|
2625
2931
|
ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT
|
|
2626
2932
|
{
|
|
2627
2933
|
WL w;
|
|
2628
2934
|
|
|
2629
|
-
if (
|
|
2935
|
+
if (ecb_expect_false (signum <= 0 || signum >= EV_NSIG))
|
|
2630
2936
|
return;
|
|
2631
2937
|
|
|
2632
2938
|
--signum;
|
|
@@ -2635,7 +2941,7 @@ ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT
|
|
|
2635
2941
|
/* it is permissible to try to feed a signal to the wrong loop */
|
|
2636
2942
|
/* or, likely more useful, feeding a signal nobody is waiting for */
|
|
2637
2943
|
|
|
2638
|
-
if (
|
|
2944
|
+
if (ecb_expect_false (signals [signum].loop != EV_A))
|
|
2639
2945
|
return;
|
|
2640
2946
|
#endif
|
|
2641
2947
|
|
|
@@ -2729,6 +3035,57 @@ childcb (EV_P_ ev_signal *sw, int revents)
|
|
|
2729
3035
|
|
|
2730
3036
|
/*****************************************************************************/
|
|
2731
3037
|
|
|
3038
|
+
#if EV_USE_TIMERFD
|
|
3039
|
+
|
|
3040
|
+
static void periodics_reschedule (EV_P);
|
|
3041
|
+
|
|
3042
|
+
static void
|
|
3043
|
+
timerfdcb (EV_P_ ev_io *iow, int revents)
|
|
3044
|
+
{
|
|
3045
|
+
struct itimerspec its = { 0 };
|
|
3046
|
+
|
|
3047
|
+
its.it_value.tv_sec = ev_rt_now + (int)MAX_BLOCKTIME2;
|
|
3048
|
+
timerfd_settime (timerfd, TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET, &its, 0);
|
|
3049
|
+
|
|
3050
|
+
ev_rt_now = ev_time ();
|
|
3051
|
+
/* periodics_reschedule only needs ev_rt_now */
|
|
3052
|
+
/* but maybe in the future we want the full treatment. */
|
|
3053
|
+
/*
|
|
3054
|
+
now_floor = EV_TS_CONST (0.);
|
|
3055
|
+
time_update (EV_A_ EV_TSTAMP_HUGE);
|
|
3056
|
+
*/
|
|
3057
|
+
#if EV_PERIODIC_ENABLE
|
|
3058
|
+
periodics_reschedule (EV_A);
|
|
3059
|
+
#endif
|
|
3060
|
+
}
|
|
3061
|
+
|
|
3062
|
+
ecb_noinline ecb_cold
|
|
3063
|
+
static void
|
|
3064
|
+
evtimerfd_init (EV_P)
|
|
3065
|
+
{
|
|
3066
|
+
if (!ev_is_active (&timerfd_w))
|
|
3067
|
+
{
|
|
3068
|
+
timerfd = timerfd_create (CLOCK_REALTIME, TFD_NONBLOCK | TFD_CLOEXEC);
|
|
3069
|
+
|
|
3070
|
+
if (timerfd >= 0)
|
|
3071
|
+
{
|
|
3072
|
+
fd_intern (timerfd); /* just to be sure */
|
|
3073
|
+
|
|
3074
|
+
ev_io_init (&timerfd_w, timerfdcb, timerfd, EV_READ);
|
|
3075
|
+
ev_set_priority (&timerfd_w, EV_MINPRI);
|
|
3076
|
+
ev_io_start (EV_A_ &timerfd_w);
|
|
3077
|
+
ev_unref (EV_A); /* watcher should not keep loop alive */
|
|
3078
|
+
|
|
3079
|
+
/* (re-) arm timer */
|
|
3080
|
+
timerfdcb (EV_A_ 0, 0);
|
|
3081
|
+
}
|
|
3082
|
+
}
|
|
3083
|
+
}
|
|
3084
|
+
|
|
3085
|
+
#endif
|
|
3086
|
+
|
|
3087
|
+
/*****************************************************************************/
|
|
3088
|
+
|
|
2732
3089
|
#if EV_USE_IOCP
|
|
2733
3090
|
# include "ev_iocp.c"
|
|
2734
3091
|
#endif
|
|
@@ -2744,6 +3101,9 @@ childcb (EV_P_ ev_signal *sw, int revents)
|
|
|
2744
3101
|
#if EV_USE_LINUXAIO
|
|
2745
3102
|
# include "ev_linuxaio.c"
|
|
2746
3103
|
#endif
|
|
3104
|
+
#if EV_USE_IOURING
|
|
3105
|
+
# include "ev_iouring.c"
|
|
3106
|
+
#endif
|
|
2747
3107
|
#if EV_USE_POLL
|
|
2748
3108
|
# include "ev_poll.c"
|
|
2749
3109
|
#endif
|
|
@@ -2781,17 +3141,14 @@ ev_supported_backends (void) EV_NOEXCEPT
|
|
|
2781
3141
|
{
|
|
2782
3142
|
unsigned int flags = 0;
|
|
2783
3143
|
|
|
2784
|
-
if (EV_USE_PORT
|
|
2785
|
-
if (EV_USE_KQUEUE
|
|
2786
|
-
if (EV_USE_EPOLL
|
|
2787
|
-
|
|
2788
|
-
|
|
2789
|
-
if (
|
|
2790
|
-
|
|
3144
|
+
if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
|
|
3145
|
+
if (EV_USE_KQUEUE ) flags |= EVBACKEND_KQUEUE;
|
|
3146
|
+
if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
|
|
3147
|
+
if (EV_USE_LINUXAIO && ev_linux_version () >= 0x041300) flags |= EVBACKEND_LINUXAIO; /* 4.19+ */
|
|
3148
|
+
if (EV_USE_IOURING && ev_linux_version () >= 0x050601 ) flags |= EVBACKEND_IOURING; /* 5.6.1+ */
|
|
3149
|
+
if (EV_USE_POLL ) flags |= EVBACKEND_POLL;
|
|
3150
|
+
if (EV_USE_SELECT ) flags |= EVBACKEND_SELECT;
|
|
2791
3151
|
|
|
2792
|
-
if (EV_USE_POLL ) flags |= EVBACKEND_POLL;
|
|
2793
|
-
if (EV_USE_SELECT ) flags |= EVBACKEND_SELECT;
|
|
2794
|
-
|
|
2795
3152
|
return flags;
|
|
2796
3153
|
}
|
|
2797
3154
|
|
|
@@ -2801,24 +3158,27 @@ ev_recommended_backends (void) EV_NOEXCEPT
|
|
|
2801
3158
|
{
|
|
2802
3159
|
unsigned int flags = ev_supported_backends ();
|
|
2803
3160
|
|
|
2804
|
-
|
|
2805
|
-
|
|
2806
|
-
#elif defined(__NetBSD__)
|
|
2807
|
-
/* kqueue is borked on everything but netbsd apparently */
|
|
2808
|
-
/* it usually doesn't work correctly on anything but sockets and pipes */
|
|
2809
|
-
#else
|
|
3161
|
+
/* apple has a poor track record but post 10.12.2 it seems to work sufficiently well */
|
|
3162
|
+
#if defined(__APPLE__) && (MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_14)
|
|
2810
3163
|
/* only select works correctly on that "unix-certified" platform */
|
|
2811
3164
|
flags &= ~EVBACKEND_KQUEUE; /* horribly broken, even for sockets */
|
|
2812
3165
|
flags &= ~EVBACKEND_POLL; /* poll is based on kqueue from 10.5 onwards */
|
|
3166
|
+
#elif !defined(__NetBSD__)
|
|
3167
|
+
/* kqueue is borked on everything but netbsd apparently */
|
|
3168
|
+
/* it usually doesn't work correctly on anything but sockets and pipes */
|
|
3169
|
+
flags &= ~EVBACKEND_KQUEUE;
|
|
2813
3170
|
#endif
|
|
2814
3171
|
|
|
2815
3172
|
#ifdef __FreeBSD__
|
|
2816
3173
|
flags &= ~EVBACKEND_POLL; /* poll return value is unusable (http://forums.freebsd.org/archive/index.php/t-10270.html) */
|
|
2817
3174
|
#endif
|
|
2818
3175
|
|
|
2819
|
-
|
|
2820
|
-
|
|
3176
|
+
#ifdef __linux__
|
|
3177
|
+
/* NOTE: linuxaio is very experimental, never recommend */
|
|
2821
3178
|
flags &= ~EVBACKEND_LINUXAIO;
|
|
3179
|
+
|
|
3180
|
+
/* NOTE: io_uring is super experimental, never recommend */
|
|
3181
|
+
flags &= ~EVBACKEND_IOURING;
|
|
2822
3182
|
#endif
|
|
2823
3183
|
|
|
2824
3184
|
return flags;
|
|
@@ -2828,12 +3188,14 @@ ecb_cold
|
|
|
2828
3188
|
unsigned int
|
|
2829
3189
|
ev_embeddable_backends (void) EV_NOEXCEPT
|
|
2830
3190
|
{
|
|
2831
|
-
int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;
|
|
3191
|
+
int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT | EVBACKEND_IOURING;
|
|
2832
3192
|
|
|
2833
3193
|
/* epoll embeddability broken on all linux versions up to at least 2.6.23 */
|
|
2834
3194
|
if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
|
|
2835
3195
|
flags &= ~EVBACKEND_EPOLL;
|
|
2836
3196
|
|
|
3197
|
+
/* EVBACKEND_LINUXAIO is theoretically embeddable, but suffers from a performance overhead */
|
|
3198
|
+
|
|
2837
3199
|
return flags;
|
|
2838
3200
|
}
|
|
2839
3201
|
|
|
@@ -2895,7 +3257,7 @@ ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_NOEXCEPT, void (*acquire)
|
|
|
2895
3257
|
#endif
|
|
2896
3258
|
|
|
2897
3259
|
/* initialise a loop structure, must be zero-initialised */
|
|
2898
|
-
|
|
3260
|
+
ecb_noinline ecb_cold
|
|
2899
3261
|
static void
|
|
2900
3262
|
loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT
|
|
2901
3263
|
{
|
|
@@ -2960,6 +3322,9 @@ loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT
|
|
|
2960
3322
|
#if EV_USE_SIGNALFD
|
|
2961
3323
|
sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
|
|
2962
3324
|
#endif
|
|
3325
|
+
#if EV_USE_TIMERFD
|
|
3326
|
+
timerfd = flags & EVFLAG_NOTIMERFD ? -1 : -2;
|
|
3327
|
+
#endif
|
|
2963
3328
|
|
|
2964
3329
|
if (!(flags & EVBACKEND_MASK))
|
|
2965
3330
|
flags |= ev_recommended_backends ();
|
|
@@ -2973,6 +3338,9 @@ loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT
|
|
|
2973
3338
|
#if EV_USE_KQUEUE
|
|
2974
3339
|
if (!backend && (flags & EVBACKEND_KQUEUE )) backend = kqueue_init (EV_A_ flags);
|
|
2975
3340
|
#endif
|
|
3341
|
+
#if EV_USE_IOURING
|
|
3342
|
+
if (!backend && (flags & EVBACKEND_IOURING )) backend = iouring_init (EV_A_ flags);
|
|
3343
|
+
#endif
|
|
2976
3344
|
#if EV_USE_LINUXAIO
|
|
2977
3345
|
if (!backend && (flags & EVBACKEND_LINUXAIO)) backend = linuxaio_init (EV_A_ flags);
|
|
2978
3346
|
#endif
|
|
@@ -3010,7 +3378,7 @@ ev_loop_destroy (EV_P)
|
|
|
3010
3378
|
|
|
3011
3379
|
#if EV_CLEANUP_ENABLE
|
|
3012
3380
|
/* queue cleanup watchers (and execute them) */
|
|
3013
|
-
if (
|
|
3381
|
+
if (ecb_expect_false (cleanupcnt))
|
|
3014
3382
|
{
|
|
3015
3383
|
queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);
|
|
3016
3384
|
EV_INVOKE_PENDING;
|
|
@@ -3039,6 +3407,11 @@ ev_loop_destroy (EV_P)
|
|
|
3039
3407
|
close (sigfd);
|
|
3040
3408
|
#endif
|
|
3041
3409
|
|
|
3410
|
+
#if EV_USE_TIMERFD
|
|
3411
|
+
if (ev_is_active (&timerfd_w))
|
|
3412
|
+
close (timerfd);
|
|
3413
|
+
#endif
|
|
3414
|
+
|
|
3042
3415
|
#if EV_USE_INOTIFY
|
|
3043
3416
|
if (fs_fd >= 0)
|
|
3044
3417
|
close (fs_fd);
|
|
@@ -3056,6 +3429,9 @@ ev_loop_destroy (EV_P)
|
|
|
3056
3429
|
#if EV_USE_KQUEUE
|
|
3057
3430
|
if (backend == EVBACKEND_KQUEUE ) kqueue_destroy (EV_A);
|
|
3058
3431
|
#endif
|
|
3432
|
+
#if EV_USE_IOURING
|
|
3433
|
+
if (backend == EVBACKEND_IOURING ) iouring_destroy (EV_A);
|
|
3434
|
+
#endif
|
|
3059
3435
|
#if EV_USE_LINUXAIO
|
|
3060
3436
|
if (backend == EVBACKEND_LINUXAIO) linuxaio_destroy (EV_A);
|
|
3061
3437
|
#endif
|
|
@@ -3123,6 +3499,9 @@ loop_fork (EV_P)
|
|
|
3123
3499
|
#if EV_USE_KQUEUE
|
|
3124
3500
|
if (backend == EVBACKEND_KQUEUE ) kqueue_fork (EV_A);
|
|
3125
3501
|
#endif
|
|
3502
|
+
#if EV_USE_IOURING
|
|
3503
|
+
if (backend == EVBACKEND_IOURING ) iouring_fork (EV_A);
|
|
3504
|
+
#endif
|
|
3126
3505
|
#if EV_USE_LINUXAIO
|
|
3127
3506
|
if (backend == EVBACKEND_LINUXAIO) linuxaio_fork (EV_A);
|
|
3128
3507
|
#endif
|
|
@@ -3133,22 +3512,44 @@ loop_fork (EV_P)
|
|
|
3133
3512
|
infy_fork (EV_A);
|
|
3134
3513
|
#endif
|
|
3135
3514
|
|
|
3136
|
-
|
|
3137
|
-
if (ev_is_active (&pipe_w) && postfork != 2)
|
|
3515
|
+
if (postfork != 2)
|
|
3138
3516
|
{
|
|
3139
|
-
|
|
3517
|
+
#if EV_USE_SIGNALFD
|
|
3518
|
+
/* surprisingly, nothing needs to be done for signalfd, accoridng to docs, it does the right thing on fork */
|
|
3519
|
+
#endif
|
|
3140
3520
|
|
|
3141
|
-
|
|
3142
|
-
|
|
3521
|
+
#if EV_USE_TIMERFD
|
|
3522
|
+
if (ev_is_active (&timerfd_w))
|
|
3523
|
+
{
|
|
3524
|
+
ev_ref (EV_A);
|
|
3525
|
+
ev_io_stop (EV_A_ &timerfd_w);
|
|
3143
3526
|
|
|
3144
|
-
|
|
3145
|
-
|
|
3527
|
+
close (timerfd);
|
|
3528
|
+
timerfd = -2;
|
|
3529
|
+
|
|
3530
|
+
evtimerfd_init (EV_A);
|
|
3531
|
+
/* reschedule periodics, in case we missed something */
|
|
3532
|
+
ev_feed_event (EV_A_ &timerfd_w, EV_CUSTOM);
|
|
3533
|
+
}
|
|
3534
|
+
#endif
|
|
3146
3535
|
|
|
3147
|
-
|
|
3148
|
-
|
|
3149
|
-
|
|
3536
|
+
#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
|
|
3537
|
+
if (ev_is_active (&pipe_w))
|
|
3538
|
+
{
|
|
3539
|
+
/* pipe_write_wanted must be false now, so modifying fd vars should be safe */
|
|
3540
|
+
|
|
3541
|
+
ev_ref (EV_A);
|
|
3542
|
+
ev_io_stop (EV_A_ &pipe_w);
|
|
3543
|
+
|
|
3544
|
+
if (evpipe [0] >= 0)
|
|
3545
|
+
EV_WIN32_CLOSE_FD (evpipe [0]);
|
|
3546
|
+
|
|
3547
|
+
evpipe_init (EV_A);
|
|
3548
|
+
/* iterate over everything, in case we missed something before */
|
|
3549
|
+
ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
|
|
3550
|
+
}
|
|
3551
|
+
#endif
|
|
3150
3552
|
}
|
|
3151
|
-
#endif
|
|
3152
3553
|
|
|
3153
3554
|
postfork = 0;
|
|
3154
3555
|
}
|
|
@@ -3174,7 +3575,7 @@ ev_loop_new (unsigned int flags) EV_NOEXCEPT
|
|
|
3174
3575
|
#endif /* multiplicity */
|
|
3175
3576
|
|
|
3176
3577
|
#if EV_VERIFY
|
|
3177
|
-
|
|
3578
|
+
ecb_noinline ecb_cold
|
|
3178
3579
|
static void
|
|
3179
3580
|
verify_watcher (EV_P_ W w)
|
|
3180
3581
|
{
|
|
@@ -3184,7 +3585,7 @@ verify_watcher (EV_P_ W w)
|
|
|
3184
3585
|
assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));
|
|
3185
3586
|
}
|
|
3186
3587
|
|
|
3187
|
-
|
|
3588
|
+
ecb_noinline ecb_cold
|
|
3188
3589
|
static void
|
|
3189
3590
|
verify_heap (EV_P_ ANHE *heap, int N)
|
|
3190
3591
|
{
|
|
@@ -3200,7 +3601,7 @@ verify_heap (EV_P_ ANHE *heap, int N)
|
|
|
3200
3601
|
}
|
|
3201
3602
|
}
|
|
3202
3603
|
|
|
3203
|
-
|
|
3604
|
+
ecb_noinline ecb_cold
|
|
3204
3605
|
static void
|
|
3205
3606
|
array_verify (EV_P_ W *ws, int cnt)
|
|
3206
3607
|
{
|
|
@@ -3359,7 +3760,7 @@ ev_pending_count (EV_P) EV_NOEXCEPT
|
|
|
3359
3760
|
return count;
|
|
3360
3761
|
}
|
|
3361
3762
|
|
|
3362
|
-
|
|
3763
|
+
ecb_noinline
|
|
3363
3764
|
void
|
|
3364
3765
|
ev_invoke_pending (EV_P)
|
|
3365
3766
|
{
|
|
@@ -3388,7 +3789,7 @@ ev_invoke_pending (EV_P)
|
|
|
3388
3789
|
inline_size void
|
|
3389
3790
|
idle_reify (EV_P)
|
|
3390
3791
|
{
|
|
3391
|
-
if (
|
|
3792
|
+
if (ecb_expect_false (idleall))
|
|
3392
3793
|
{
|
|
3393
3794
|
int pri;
|
|
3394
3795
|
|
|
@@ -3428,7 +3829,7 @@ timers_reify (EV_P)
|
|
|
3428
3829
|
if (ev_at (w) < mn_now)
|
|
3429
3830
|
ev_at (w) = mn_now;
|
|
3430
3831
|
|
|
3431
|
-
assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > 0.));
|
|
3832
|
+
assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > EV_TS_CONST (0.)));
|
|
3432
3833
|
|
|
3433
3834
|
ANHE_at_cache (timers [HEAP0]);
|
|
3434
3835
|
downheap (timers, timercnt, HEAP0);
|
|
@@ -3447,7 +3848,7 @@ timers_reify (EV_P)
|
|
|
3447
3848
|
|
|
3448
3849
|
#if EV_PERIODIC_ENABLE
|
|
3449
3850
|
|
|
3450
|
-
|
|
3851
|
+
ecb_noinline
|
|
3451
3852
|
static void
|
|
3452
3853
|
periodic_recalc (EV_P_ ev_periodic *w)
|
|
3453
3854
|
{
|
|
@@ -3460,7 +3861,7 @@ periodic_recalc (EV_P_ ev_periodic *w)
|
|
|
3460
3861
|
ev_tstamp nat = at + w->interval;
|
|
3461
3862
|
|
|
3462
3863
|
/* when resolution fails us, we use ev_rt_now */
|
|
3463
|
-
if (
|
|
3864
|
+
if (ecb_expect_false (nat == at))
|
|
3464
3865
|
{
|
|
3465
3866
|
at = ev_rt_now;
|
|
3466
3867
|
break;
|
|
@@ -3516,7 +3917,7 @@ periodics_reify (EV_P)
|
|
|
3516
3917
|
|
|
3517
3918
|
/* simply recalculate all periodics */
|
|
3518
3919
|
/* TODO: maybe ensure that at least one event happens when jumping forward? */
|
|
3519
|
-
|
|
3920
|
+
ecb_noinline ecb_cold
|
|
3520
3921
|
static void
|
|
3521
3922
|
periodics_reschedule (EV_P)
|
|
3522
3923
|
{
|
|
@@ -3540,7 +3941,7 @@ periodics_reschedule (EV_P)
|
|
|
3540
3941
|
#endif
|
|
3541
3942
|
|
|
3542
3943
|
/* adjust all timers by a given offset */
|
|
3543
|
-
|
|
3944
|
+
ecb_noinline ecb_cold
|
|
3544
3945
|
static void
|
|
3545
3946
|
timers_reschedule (EV_P_ ev_tstamp adjust)
|
|
3546
3947
|
{
|
|
@@ -3560,7 +3961,7 @@ inline_speed void
|
|
|
3560
3961
|
time_update (EV_P_ ev_tstamp max_block)
|
|
3561
3962
|
{
|
|
3562
3963
|
#if EV_USE_MONOTONIC
|
|
3563
|
-
if (
|
|
3964
|
+
if (ecb_expect_true (have_monotonic))
|
|
3564
3965
|
{
|
|
3565
3966
|
int i;
|
|
3566
3967
|
ev_tstamp odiff = rtmn_diff;
|
|
@@ -3569,7 +3970,7 @@ time_update (EV_P_ ev_tstamp max_block)
|
|
|
3569
3970
|
|
|
3570
3971
|
/* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */
|
|
3571
3972
|
/* interpolate in the meantime */
|
|
3572
|
-
if (
|
|
3973
|
+
if (ecb_expect_true (mn_now - now_floor < EV_TS_CONST (MIN_TIMEJUMP * .5)))
|
|
3573
3974
|
{
|
|
3574
3975
|
ev_rt_now = rtmn_diff + mn_now;
|
|
3575
3976
|
return;
|
|
@@ -3593,7 +3994,7 @@ time_update (EV_P_ ev_tstamp max_block)
|
|
|
3593
3994
|
|
|
3594
3995
|
diff = odiff - rtmn_diff;
|
|
3595
3996
|
|
|
3596
|
-
if (
|
|
3997
|
+
if (ecb_expect_true ((diff < EV_TS_CONST (0.) ? -diff : diff) < EV_TS_CONST (MIN_TIMEJUMP)))
|
|
3597
3998
|
return; /* all is well */
|
|
3598
3999
|
|
|
3599
4000
|
ev_rt_now = ev_time ();
|
|
@@ -3612,7 +4013,7 @@ time_update (EV_P_ ev_tstamp max_block)
|
|
|
3612
4013
|
{
|
|
3613
4014
|
ev_rt_now = ev_time ();
|
|
3614
4015
|
|
|
3615
|
-
if (
|
|
4016
|
+
if (ecb_expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + EV_TS_CONST (MIN_TIMEJUMP)))
|
|
3616
4017
|
{
|
|
3617
4018
|
/* adjust timers. this is easy, as the offset is the same for all of them */
|
|
3618
4019
|
timers_reschedule (EV_A_ ev_rt_now - mn_now);
|
|
@@ -3666,8 +4067,8 @@ ev_run (EV_P_ int flags)
|
|
|
3666
4067
|
#endif
|
|
3667
4068
|
|
|
3668
4069
|
#ifndef _WIN32
|
|
3669
|
-
if (
|
|
3670
|
-
if (
|
|
4070
|
+
if (ecb_expect_false (curpid)) /* penalise the forking check even more */
|
|
4071
|
+
if (ecb_expect_false (getpid () != curpid))
|
|
3671
4072
|
{
|
|
3672
4073
|
curpid = getpid ();
|
|
3673
4074
|
postfork = 1;
|
|
@@ -3676,7 +4077,7 @@ ev_run (EV_P_ int flags)
|
|
|
3676
4077
|
|
|
3677
4078
|
#if EV_FORK_ENABLE
|
|
3678
4079
|
/* we might have forked, so queue fork handlers */
|
|
3679
|
-
if (
|
|
4080
|
+
if (ecb_expect_false (postfork))
|
|
3680
4081
|
if (forkcnt)
|
|
3681
4082
|
{
|
|
3682
4083
|
queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
|
|
@@ -3686,18 +4087,18 @@ ev_run (EV_P_ int flags)
|
|
|
3686
4087
|
|
|
3687
4088
|
#if EV_PREPARE_ENABLE
|
|
3688
4089
|
/* queue prepare watchers (and execute them) */
|
|
3689
|
-
if (
|
|
4090
|
+
if (ecb_expect_false (preparecnt))
|
|
3690
4091
|
{
|
|
3691
4092
|
queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
|
|
3692
4093
|
EV_INVOKE_PENDING;
|
|
3693
4094
|
}
|
|
3694
4095
|
#endif
|
|
3695
4096
|
|
|
3696
|
-
if (
|
|
4097
|
+
if (ecb_expect_false (loop_done))
|
|
3697
4098
|
break;
|
|
3698
4099
|
|
|
3699
4100
|
/* we might have forked, so reify kernel state if necessary */
|
|
3700
|
-
if (
|
|
4101
|
+
if (ecb_expect_false (postfork))
|
|
3701
4102
|
loop_fork (EV_A);
|
|
3702
4103
|
|
|
3703
4104
|
/* update fd-related kernel structures */
|
|
@@ -3712,16 +4113,28 @@ ev_run (EV_P_ int flags)
|
|
|
3712
4113
|
ev_tstamp prev_mn_now = mn_now;
|
|
3713
4114
|
|
|
3714
4115
|
/* update time to cancel out callback processing overhead */
|
|
3715
|
-
time_update (EV_A_
|
|
4116
|
+
time_update (EV_A_ EV_TS_CONST (EV_TSTAMP_HUGE));
|
|
3716
4117
|
|
|
3717
4118
|
/* from now on, we want a pipe-wake-up */
|
|
3718
4119
|
pipe_write_wanted = 1;
|
|
3719
4120
|
|
|
3720
4121
|
ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */
|
|
3721
4122
|
|
|
3722
|
-
if (
|
|
4123
|
+
if (ecb_expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))
|
|
3723
4124
|
{
|
|
3724
|
-
waittime = MAX_BLOCKTIME;
|
|
4125
|
+
waittime = EV_TS_CONST (MAX_BLOCKTIME);
|
|
4126
|
+
|
|
4127
|
+
#if EV_USE_TIMERFD
|
|
4128
|
+
/* sleep a lot longer when we can reliably detect timejumps */
|
|
4129
|
+
if (ecb_expect_true (timerfd >= 0))
|
|
4130
|
+
waittime = EV_TS_CONST (MAX_BLOCKTIME2);
|
|
4131
|
+
#endif
|
|
4132
|
+
#if !EV_PERIODIC_ENABLE
|
|
4133
|
+
/* without periodics but with monotonic clock there is no need */
|
|
4134
|
+
/* for any time jump detection, so sleep longer */
|
|
4135
|
+
if (ecb_expect_true (have_monotonic))
|
|
4136
|
+
waittime = EV_TS_CONST (MAX_BLOCKTIME2);
|
|
4137
|
+
#endif
|
|
3725
4138
|
|
|
3726
4139
|
if (timercnt)
|
|
3727
4140
|
{
|
|
@@ -3738,23 +4151,28 @@ ev_run (EV_P_ int flags)
|
|
|
3738
4151
|
#endif
|
|
3739
4152
|
|
|
3740
4153
|
/* don't let timeouts decrease the waittime below timeout_blocktime */
|
|
3741
|
-
if (
|
|
4154
|
+
if (ecb_expect_false (waittime < timeout_blocktime))
|
|
3742
4155
|
waittime = timeout_blocktime;
|
|
3743
4156
|
|
|
3744
|
-
/*
|
|
3745
|
-
|
|
3746
|
-
|
|
3747
|
-
|
|
4157
|
+
/* now there are two more special cases left, either we have
|
|
4158
|
+
* already-expired timers, so we should not sleep, or we have timers
|
|
4159
|
+
* that expire very soon, in which case we need to wait for a minimum
|
|
4160
|
+
* amount of time for some event loop backends.
|
|
4161
|
+
*/
|
|
4162
|
+
if (ecb_expect_false (waittime < backend_mintime))
|
|
4163
|
+
waittime = waittime <= EV_TS_CONST (0.)
|
|
4164
|
+
? EV_TS_CONST (0.)
|
|
4165
|
+
: backend_mintime;
|
|
3748
4166
|
|
|
3749
4167
|
/* extra check because io_blocktime is commonly 0 */
|
|
3750
|
-
if (
|
|
4168
|
+
if (ecb_expect_false (io_blocktime))
|
|
3751
4169
|
{
|
|
3752
4170
|
sleeptime = io_blocktime - (mn_now - prev_mn_now);
|
|
3753
4171
|
|
|
3754
4172
|
if (sleeptime > waittime - backend_mintime)
|
|
3755
4173
|
sleeptime = waittime - backend_mintime;
|
|
3756
4174
|
|
|
3757
|
-
if (
|
|
4175
|
+
if (ecb_expect_true (sleeptime > EV_TS_CONST (0.)))
|
|
3758
4176
|
{
|
|
3759
4177
|
ev_sleep (sleeptime);
|
|
3760
4178
|
waittime -= sleeptime;
|
|
@@ -3809,10 +4227,7 @@ rb_thread_unsafe_dangerous_crazy_blocking_region_end(...);
|
|
|
3809
4227
|
|
|
3810
4228
|
poll_args.loop = loop;
|
|
3811
4229
|
poll_args.waittime = waittime;
|
|
3812
|
-
|
|
3813
4230
|
rb_thread_call_without_gvl(ev_backend_poll, (void *)&poll_args, RUBY_UBF_IO, 0);
|
|
3814
|
-
|
|
3815
|
-
// backend_poll (EV_A_ waittime);
|
|
3816
4231
|
/*
|
|
3817
4232
|
############################# END PATCHERY ############################
|
|
3818
4233
|
*/
|
|
@@ -3828,7 +4243,6 @@ rb_thread_unsafe_dangerous_crazy_blocking_region_end(...);
|
|
|
3828
4243
|
ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
|
|
3829
4244
|
}
|
|
3830
4245
|
|
|
3831
|
-
|
|
3832
4246
|
/* update ev_rt_now, do magic */
|
|
3833
4247
|
time_update (EV_A_ waittime + sleeptime);
|
|
3834
4248
|
}
|
|
@@ -3846,13 +4260,13 @@ rb_thread_unsafe_dangerous_crazy_blocking_region_end(...);
|
|
|
3846
4260
|
|
|
3847
4261
|
#if EV_CHECK_ENABLE
|
|
3848
4262
|
/* queue check watchers, to be executed first */
|
|
3849
|
-
if (
|
|
4263
|
+
if (ecb_expect_false (checkcnt))
|
|
3850
4264
|
queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
|
|
3851
4265
|
#endif
|
|
3852
4266
|
|
|
3853
4267
|
EV_INVOKE_PENDING;
|
|
3854
4268
|
}
|
|
3855
|
-
while (
|
|
4269
|
+
while (ecb_expect_true (
|
|
3856
4270
|
activecnt
|
|
3857
4271
|
&& !loop_done
|
|
3858
4272
|
&& !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))
|
|
@@ -3889,7 +4303,7 @@ ev_unref (EV_P) EV_NOEXCEPT
|
|
|
3889
4303
|
void
|
|
3890
4304
|
ev_now_update (EV_P) EV_NOEXCEPT
|
|
3891
4305
|
{
|
|
3892
|
-
time_update (EV_A_
|
|
4306
|
+
time_update (EV_A_ EV_TSTAMP_HUGE);
|
|
3893
4307
|
}
|
|
3894
4308
|
|
|
3895
4309
|
void
|
|
@@ -3926,7 +4340,7 @@ wlist_del (WL *head, WL elem)
|
|
|
3926
4340
|
{
|
|
3927
4341
|
while (*head)
|
|
3928
4342
|
{
|
|
3929
|
-
if (
|
|
4343
|
+
if (ecb_expect_true (*head == elem))
|
|
3930
4344
|
{
|
|
3931
4345
|
*head = elem->next;
|
|
3932
4346
|
break;
|
|
@@ -3953,7 +4367,7 @@ ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT
|
|
|
3953
4367
|
W w_ = (W)w;
|
|
3954
4368
|
int pending = w_->pending;
|
|
3955
4369
|
|
|
3956
|
-
if (
|
|
4370
|
+
if (ecb_expect_true (pending))
|
|
3957
4371
|
{
|
|
3958
4372
|
ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;
|
|
3959
4373
|
p->w = (W)&pending_w;
|
|
@@ -3990,13 +4404,13 @@ ev_stop (EV_P_ W w)
|
|
|
3990
4404
|
|
|
3991
4405
|
/*****************************************************************************/
|
|
3992
4406
|
|
|
3993
|
-
|
|
4407
|
+
ecb_noinline
|
|
3994
4408
|
void
|
|
3995
4409
|
ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT
|
|
3996
4410
|
{
|
|
3997
4411
|
int fd = w->fd;
|
|
3998
4412
|
|
|
3999
|
-
if (
|
|
4413
|
+
if (ecb_expect_false (ev_is_active (w)))
|
|
4000
4414
|
return;
|
|
4001
4415
|
|
|
4002
4416
|
assert (("libev: ev_io_start called with negative fd", fd >= 0));
|
|
@@ -4020,12 +4434,12 @@ ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT
|
|
|
4020
4434
|
EV_FREQUENT_CHECK;
|
|
4021
4435
|
}
|
|
4022
4436
|
|
|
4023
|
-
|
|
4437
|
+
ecb_noinline
|
|
4024
4438
|
void
|
|
4025
4439
|
ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT
|
|
4026
4440
|
{
|
|
4027
4441
|
clear_pending (EV_A_ (W)w);
|
|
4028
|
-
if (
|
|
4442
|
+
if (ecb_expect_false (!ev_is_active (w)))
|
|
4029
4443
|
return;
|
|
4030
4444
|
|
|
4031
4445
|
assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
|
|
@@ -4043,11 +4457,11 @@ ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT
|
|
|
4043
4457
|
EV_FREQUENT_CHECK;
|
|
4044
4458
|
}
|
|
4045
4459
|
|
|
4046
|
-
|
|
4460
|
+
ecb_noinline
|
|
4047
4461
|
void
|
|
4048
4462
|
ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT
|
|
4049
4463
|
{
|
|
4050
|
-
if (
|
|
4464
|
+
if (ecb_expect_false (ev_is_active (w)))
|
|
4051
4465
|
return;
|
|
4052
4466
|
|
|
4053
4467
|
ev_at (w) += mn_now;
|
|
@@ -4068,12 +4482,12 @@ ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT
|
|
|
4068
4482
|
/*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
|
|
4069
4483
|
}
|
|
4070
4484
|
|
|
4071
|
-
|
|
4485
|
+
ecb_noinline
|
|
4072
4486
|
void
|
|
4073
4487
|
ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT
|
|
4074
4488
|
{
|
|
4075
4489
|
clear_pending (EV_A_ (W)w);
|
|
4076
|
-
if (
|
|
4490
|
+
if (ecb_expect_false (!ev_is_active (w)))
|
|
4077
4491
|
return;
|
|
4078
4492
|
|
|
4079
4493
|
EV_FREQUENT_CHECK;
|
|
@@ -4085,7 +4499,7 @@ ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT
|
|
|
4085
4499
|
|
|
4086
4500
|
--timercnt;
|
|
4087
4501
|
|
|
4088
|
-
if (
|
|
4502
|
+
if (ecb_expect_true (active < timercnt + HEAP0))
|
|
4089
4503
|
{
|
|
4090
4504
|
timers [active] = timers [timercnt + HEAP0];
|
|
4091
4505
|
adjustheap (timers, timercnt, active);
|
|
@@ -4099,7 +4513,7 @@ ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT
|
|
|
4099
4513
|
EV_FREQUENT_CHECK;
|
|
4100
4514
|
}
|
|
4101
4515
|
|
|
4102
|
-
|
|
4516
|
+
ecb_noinline
|
|
4103
4517
|
void
|
|
4104
4518
|
ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT
|
|
4105
4519
|
{
|
|
@@ -4130,17 +4544,22 @@ ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT
|
|
|
4130
4544
|
ev_tstamp
|
|
4131
4545
|
ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT
|
|
4132
4546
|
{
|
|
4133
|
-
return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
|
|
4547
|
+
return ev_at (w) - (ev_is_active (w) ? mn_now : EV_TS_CONST (0.));
|
|
4134
4548
|
}
|
|
4135
4549
|
|
|
4136
4550
|
#if EV_PERIODIC_ENABLE
|
|
4137
|
-
|
|
4551
|
+
ecb_noinline
|
|
4138
4552
|
void
|
|
4139
4553
|
ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT
|
|
4140
4554
|
{
|
|
4141
|
-
if (
|
|
4555
|
+
if (ecb_expect_false (ev_is_active (w)))
|
|
4142
4556
|
return;
|
|
4143
4557
|
|
|
4558
|
+
#if EV_USE_TIMERFD
|
|
4559
|
+
if (timerfd == -2)
|
|
4560
|
+
evtimerfd_init (EV_A);
|
|
4561
|
+
#endif
|
|
4562
|
+
|
|
4144
4563
|
if (w->reschedule_cb)
|
|
4145
4564
|
ev_at (w) = w->reschedule_cb (w, ev_rt_now);
|
|
4146
4565
|
else if (w->interval)
|
|
@@ -4165,12 +4584,12 @@ ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT
|
|
|
4165
4584
|
/*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
|
|
4166
4585
|
}
|
|
4167
4586
|
|
|
4168
|
-
|
|
4587
|
+
ecb_noinline
|
|
4169
4588
|
void
|
|
4170
4589
|
ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT
|
|
4171
4590
|
{
|
|
4172
4591
|
clear_pending (EV_A_ (W)w);
|
|
4173
|
-
if (
|
|
4592
|
+
if (ecb_expect_false (!ev_is_active (w)))
|
|
4174
4593
|
return;
|
|
4175
4594
|
|
|
4176
4595
|
EV_FREQUENT_CHECK;
|
|
@@ -4182,7 +4601,7 @@ ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT
|
|
|
4182
4601
|
|
|
4183
4602
|
--periodiccnt;
|
|
4184
4603
|
|
|
4185
|
-
if (
|
|
4604
|
+
if (ecb_expect_true (active < periodiccnt + HEAP0))
|
|
4186
4605
|
{
|
|
4187
4606
|
periodics [active] = periodics [periodiccnt + HEAP0];
|
|
4188
4607
|
adjustheap (periodics, periodiccnt, active);
|
|
@@ -4194,7 +4613,7 @@ ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT
|
|
|
4194
4613
|
EV_FREQUENT_CHECK;
|
|
4195
4614
|
}
|
|
4196
4615
|
|
|
4197
|
-
|
|
4616
|
+
ecb_noinline
|
|
4198
4617
|
void
|
|
4199
4618
|
ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT
|
|
4200
4619
|
{
|
|
@@ -4210,11 +4629,11 @@ ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT
|
|
|
4210
4629
|
|
|
4211
4630
|
#if EV_SIGNAL_ENABLE
|
|
4212
4631
|
|
|
4213
|
-
|
|
4632
|
+
ecb_noinline
|
|
4214
4633
|
void
|
|
4215
4634
|
ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT
|
|
4216
4635
|
{
|
|
4217
|
-
if (
|
|
4636
|
+
if (ecb_expect_false (ev_is_active (w)))
|
|
4218
4637
|
return;
|
|
4219
4638
|
|
|
4220
4639
|
assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
|
|
@@ -4293,12 +4712,12 @@ ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT
|
|
|
4293
4712
|
EV_FREQUENT_CHECK;
|
|
4294
4713
|
}
|
|
4295
4714
|
|
|
4296
|
-
|
|
4715
|
+
ecb_noinline
|
|
4297
4716
|
void
|
|
4298
4717
|
ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT
|
|
4299
4718
|
{
|
|
4300
4719
|
clear_pending (EV_A_ (W)w);
|
|
4301
|
-
if (
|
|
4720
|
+
if (ecb_expect_false (!ev_is_active (w)))
|
|
4302
4721
|
return;
|
|
4303
4722
|
|
|
4304
4723
|
EV_FREQUENT_CHECK;
|
|
@@ -4341,7 +4760,7 @@ ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT
|
|
|
4341
4760
|
#if EV_MULTIPLICITY
|
|
4342
4761
|
assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
|
|
4343
4762
|
#endif
|
|
4344
|
-
if (
|
|
4763
|
+
if (ecb_expect_false (ev_is_active (w)))
|
|
4345
4764
|
return;
|
|
4346
4765
|
|
|
4347
4766
|
EV_FREQUENT_CHECK;
|
|
@@ -4356,7 +4775,7 @@ void
|
|
|
4356
4775
|
ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT
|
|
4357
4776
|
{
|
|
4358
4777
|
clear_pending (EV_A_ (W)w);
|
|
4359
|
-
if (
|
|
4778
|
+
if (ecb_expect_false (!ev_is_active (w)))
|
|
4360
4779
|
return;
|
|
4361
4780
|
|
|
4362
4781
|
EV_FREQUENT_CHECK;
|
|
@@ -4380,14 +4799,14 @@ ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT
|
|
|
4380
4799
|
#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */
|
|
4381
4800
|
#define MIN_STAT_INTERVAL 0.1074891
|
|
4382
4801
|
|
|
4383
|
-
|
|
4802
|
+
ecb_noinline static void stat_timer_cb (EV_P_ ev_timer *w_, int revents);
|
|
4384
4803
|
|
|
4385
4804
|
#if EV_USE_INOTIFY
|
|
4386
4805
|
|
|
4387
4806
|
/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
|
|
4388
4807
|
# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
|
|
4389
4808
|
|
|
4390
|
-
|
|
4809
|
+
ecb_noinline
|
|
4391
4810
|
static void
|
|
4392
4811
|
infy_add (EV_P_ ev_stat *w)
|
|
4393
4812
|
{
|
|
@@ -4462,7 +4881,7 @@ infy_add (EV_P_ ev_stat *w)
|
|
|
4462
4881
|
if (ev_is_active (&w->timer)) ev_unref (EV_A);
|
|
4463
4882
|
}
|
|
4464
4883
|
|
|
4465
|
-
|
|
4884
|
+
ecb_noinline
|
|
4466
4885
|
static void
|
|
4467
4886
|
infy_del (EV_P_ ev_stat *w)
|
|
4468
4887
|
{
|
|
@@ -4480,7 +4899,7 @@ infy_del (EV_P_ ev_stat *w)
|
|
|
4480
4899
|
inotify_rm_watch (fs_fd, wd);
|
|
4481
4900
|
}
|
|
4482
4901
|
|
|
4483
|
-
|
|
4902
|
+
ecb_noinline
|
|
4484
4903
|
static void
|
|
4485
4904
|
infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
|
|
4486
4905
|
{
|
|
@@ -4636,7 +5055,7 @@ ev_stat_stat (EV_P_ ev_stat *w) EV_NOEXCEPT
|
|
|
4636
5055
|
w->attr.st_nlink = 1;
|
|
4637
5056
|
}
|
|
4638
5057
|
|
|
4639
|
-
|
|
5058
|
+
ecb_noinline
|
|
4640
5059
|
static void
|
|
4641
5060
|
stat_timer_cb (EV_P_ ev_timer *w_, int revents)
|
|
4642
5061
|
{
|
|
@@ -4680,7 +5099,7 @@ stat_timer_cb (EV_P_ ev_timer *w_, int revents)
|
|
|
4680
5099
|
void
|
|
4681
5100
|
ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT
|
|
4682
5101
|
{
|
|
4683
|
-
if (
|
|
5102
|
+
if (ecb_expect_false (ev_is_active (w)))
|
|
4684
5103
|
return;
|
|
4685
5104
|
|
|
4686
5105
|
ev_stat_stat (EV_A_ w);
|
|
@@ -4712,7 +5131,7 @@ void
|
|
|
4712
5131
|
ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT
|
|
4713
5132
|
{
|
|
4714
5133
|
clear_pending (EV_A_ (W)w);
|
|
4715
|
-
if (
|
|
5134
|
+
if (ecb_expect_false (!ev_is_active (w)))
|
|
4716
5135
|
return;
|
|
4717
5136
|
|
|
4718
5137
|
EV_FREQUENT_CHECK;
|
|
@@ -4737,7 +5156,7 @@ ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT
|
|
|
4737
5156
|
void
|
|
4738
5157
|
ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT
|
|
4739
5158
|
{
|
|
4740
|
-
if (
|
|
5159
|
+
if (ecb_expect_false (ev_is_active (w)))
|
|
4741
5160
|
return;
|
|
4742
5161
|
|
|
4743
5162
|
pri_adjust (EV_A_ (W)w);
|
|
@@ -4761,7 +5180,7 @@ void
|
|
|
4761
5180
|
ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT
|
|
4762
5181
|
{
|
|
4763
5182
|
clear_pending (EV_A_ (W)w);
|
|
4764
|
-
if (
|
|
5183
|
+
if (ecb_expect_false (!ev_is_active (w)))
|
|
4765
5184
|
return;
|
|
4766
5185
|
|
|
4767
5186
|
EV_FREQUENT_CHECK;
|
|
@@ -4784,7 +5203,7 @@ ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT
|
|
|
4784
5203
|
void
|
|
4785
5204
|
ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT
|
|
4786
5205
|
{
|
|
4787
|
-
if (
|
|
5206
|
+
if (ecb_expect_false (ev_is_active (w)))
|
|
4788
5207
|
return;
|
|
4789
5208
|
|
|
4790
5209
|
EV_FREQUENT_CHECK;
|
|
@@ -4800,7 +5219,7 @@ void
|
|
|
4800
5219
|
ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT
|
|
4801
5220
|
{
|
|
4802
5221
|
clear_pending (EV_A_ (W)w);
|
|
4803
|
-
if (
|
|
5222
|
+
if (ecb_expect_false (!ev_is_active (w)))
|
|
4804
5223
|
return;
|
|
4805
5224
|
|
|
4806
5225
|
EV_FREQUENT_CHECK;
|
|
@@ -4822,7 +5241,7 @@ ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT
|
|
|
4822
5241
|
void
|
|
4823
5242
|
ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT
|
|
4824
5243
|
{
|
|
4825
|
-
if (
|
|
5244
|
+
if (ecb_expect_false (ev_is_active (w)))
|
|
4826
5245
|
return;
|
|
4827
5246
|
|
|
4828
5247
|
EV_FREQUENT_CHECK;
|
|
@@ -4838,7 +5257,7 @@ void
|
|
|
4838
5257
|
ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT
|
|
4839
5258
|
{
|
|
4840
5259
|
clear_pending (EV_A_ (W)w);
|
|
4841
|
-
if (
|
|
5260
|
+
if (ecb_expect_false (!ev_is_active (w)))
|
|
4842
5261
|
return;
|
|
4843
5262
|
|
|
4844
5263
|
EV_FREQUENT_CHECK;
|
|
@@ -4857,7 +5276,7 @@ ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT
|
|
|
4857
5276
|
#endif
|
|
4858
5277
|
|
|
4859
5278
|
#if EV_EMBED_ENABLE
|
|
4860
|
-
|
|
5279
|
+
ecb_noinline
|
|
4861
5280
|
void
|
|
4862
5281
|
ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT
|
|
4863
5282
|
{
|
|
@@ -4891,6 +5310,7 @@ embed_prepare_cb (EV_P_ ev_prepare *prepare, int revents)
|
|
|
4891
5310
|
}
|
|
4892
5311
|
}
|
|
4893
5312
|
|
|
5313
|
+
#if EV_FORK_ENABLE
|
|
4894
5314
|
static void
|
|
4895
5315
|
embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)
|
|
4896
5316
|
{
|
|
@@ -4907,6 +5327,7 @@ embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)
|
|
|
4907
5327
|
|
|
4908
5328
|
ev_embed_start (EV_A_ w);
|
|
4909
5329
|
}
|
|
5330
|
+
#endif
|
|
4910
5331
|
|
|
4911
5332
|
#if 0
|
|
4912
5333
|
static void
|
|
@@ -4919,7 +5340,7 @@ embed_idle_cb (EV_P_ ev_idle *idle, int revents)
|
|
|
4919
5340
|
void
|
|
4920
5341
|
ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT
|
|
4921
5342
|
{
|
|
4922
|
-
if (
|
|
5343
|
+
if (ecb_expect_false (ev_is_active (w)))
|
|
4923
5344
|
return;
|
|
4924
5345
|
|
|
4925
5346
|
{
|
|
@@ -4937,8 +5358,10 @@ ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT
|
|
|
4937
5358
|
ev_set_priority (&w->prepare, EV_MINPRI);
|
|
4938
5359
|
ev_prepare_start (EV_A_ &w->prepare);
|
|
4939
5360
|
|
|
5361
|
+
#if EV_FORK_ENABLE
|
|
4940
5362
|
ev_fork_init (&w->fork, embed_fork_cb);
|
|
4941
5363
|
ev_fork_start (EV_A_ &w->fork);
|
|
5364
|
+
#endif
|
|
4942
5365
|
|
|
4943
5366
|
/*ev_idle_init (&w->idle, e,bed_idle_cb);*/
|
|
4944
5367
|
|
|
@@ -4951,14 +5374,16 @@ void
|
|
|
4951
5374
|
ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT
|
|
4952
5375
|
{
|
|
4953
5376
|
clear_pending (EV_A_ (W)w);
|
|
4954
|
-
if (
|
|
5377
|
+
if (ecb_expect_false (!ev_is_active (w)))
|
|
4955
5378
|
return;
|
|
4956
5379
|
|
|
4957
5380
|
EV_FREQUENT_CHECK;
|
|
4958
5381
|
|
|
4959
5382
|
ev_io_stop (EV_A_ &w->io);
|
|
4960
5383
|
ev_prepare_stop (EV_A_ &w->prepare);
|
|
5384
|
+
#if EV_FORK_ENABLE
|
|
4961
5385
|
ev_fork_stop (EV_A_ &w->fork);
|
|
5386
|
+
#endif
|
|
4962
5387
|
|
|
4963
5388
|
ev_stop (EV_A_ (W)w);
|
|
4964
5389
|
|
|
@@ -4970,7 +5395,7 @@ ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT
|
|
|
4970
5395
|
void
|
|
4971
5396
|
ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT
|
|
4972
5397
|
{
|
|
4973
|
-
if (
|
|
5398
|
+
if (ecb_expect_false (ev_is_active (w)))
|
|
4974
5399
|
return;
|
|
4975
5400
|
|
|
4976
5401
|
EV_FREQUENT_CHECK;
|
|
@@ -4986,7 +5411,7 @@ void
|
|
|
4986
5411
|
ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT
|
|
4987
5412
|
{
|
|
4988
5413
|
clear_pending (EV_A_ (W)w);
|
|
4989
|
-
if (
|
|
5414
|
+
if (ecb_expect_false (!ev_is_active (w)))
|
|
4990
5415
|
return;
|
|
4991
5416
|
|
|
4992
5417
|
EV_FREQUENT_CHECK;
|
|
@@ -5008,7 +5433,7 @@ ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT
|
|
|
5008
5433
|
void
|
|
5009
5434
|
ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT
|
|
5010
5435
|
{
|
|
5011
|
-
if (
|
|
5436
|
+
if (ecb_expect_false (ev_is_active (w)))
|
|
5012
5437
|
return;
|
|
5013
5438
|
|
|
5014
5439
|
EV_FREQUENT_CHECK;
|
|
@@ -5026,7 +5451,7 @@ void
|
|
|
5026
5451
|
ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT
|
|
5027
5452
|
{
|
|
5028
5453
|
clear_pending (EV_A_ (W)w);
|
|
5029
|
-
if (
|
|
5454
|
+
if (ecb_expect_false (!ev_is_active (w)))
|
|
5030
5455
|
return;
|
|
5031
5456
|
|
|
5032
5457
|
EV_FREQUENT_CHECK;
|
|
@@ -5049,7 +5474,7 @@ ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT
|
|
|
5049
5474
|
void
|
|
5050
5475
|
ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT
|
|
5051
5476
|
{
|
|
5052
|
-
if (
|
|
5477
|
+
if (ecb_expect_false (ev_is_active (w)))
|
|
5053
5478
|
return;
|
|
5054
5479
|
|
|
5055
5480
|
w->sent = 0;
|
|
@@ -5069,7 +5494,7 @@ void
|
|
|
5069
5494
|
ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT
|
|
5070
5495
|
{
|
|
5071
5496
|
clear_pending (EV_A_ (W)w);
|
|
5072
|
-
if (
|
|
5497
|
+
if (ecb_expect_false (!ev_is_active (w)))
|
|
5073
5498
|
return;
|
|
5074
5499
|
|
|
5075
5500
|
EV_FREQUENT_CHECK;
|
|
@@ -5276,4 +5701,3 @@ ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_NOEXCEPT
|
|
|
5276
5701
|
#if EV_MULTIPLICITY
|
|
5277
5702
|
#include "ev_wrap.h"
|
|
5278
5703
|
#endif
|
|
5279
|
-
|