See ratas@382321d2 for the
benchmark on Ratas side that tries to mimic what timeout benchmarks do.

See https://lab.nexedi.com/kirr/misc/-/blob/4f51fd6/bench/time-wheel/ratas-vs-timeout.pdf
for the result.

Not sure what I did differently on expire case, and maybe it is just Lua
vs C++, but the add and del benchmarks show that Ratas and Timeout are
of the same order in terms of performance.

I've also tried to activate LLRB-tree benchmark, and it showed that,
while expiring works faster compared to timer-wheel, adding and deleting
works siginficantly slower:

https://lab.nexedi.com/kirr/misc/-/blob/4f51fd6/bench/time-wheel/timeout-vs-llrb.pdf

For the reference original timeout vs minheap benchmark:

https://lab.nexedi.com/kirr/misc/-/blob/4f51fd6/bench/time-wheel/timeout-vs-minheap.pdf

Technically, when int is 32-bit, 1<<31 is an overflow.

Merge branch 'fixing_intervals' of git://github.com/nmathewson/timeout into nmathewson-fixing_intervals

add Lua module, move noise into subdirectories, and make build portable by only using POSIX make syntax and semantics

Also, make them check the required invariants for to->expires after
timeout_readd().

Also, actually use the different timeout values in the main()
function (whoops).

William Ahern tells me that the intent here is that timeout_readd()
should always reschedule the timeout at the first time in the future
that is an even multiple of to->interval, as if we had called:

         do {
                 to->expires += to->interval;
         } while (to->expires <= T->curtime);

But of course, that's not efficient.  The implementation strategy
used in this patch simplifies the calculation down to a single %
operation, plus a few additions and subtractions.

To verify the correctness of the formula used here, note first that
        0 <= r < to->interval, and so
        0 < to->interval - r <= to->interval.  Since
        expires' = curtime + (interval - r),
        curtime < expires' <= curtime + interval,
and so the new expiration time is no more than one interval after
curtime.

Note second that since
        r = (curtime - expires) % interval,
        expires' = curtime + (interval - r), we have
        (expires' - expires) % interval =
            (curtime + (interval - r) - expires) % interval =
            (curtime - r - expires) % interval =
            (curtime - (curtime-expires) % interval - expires) % interval =
            (curtime - curtime + expires - expires) % interval =
            0.
And so the new expiration time is an even multiple of interval from
the original expiration time.

Since we have both properties we wanted, this formula should be right.

rename timeouts_cursor to more terse timeouts_it
bumb version numbers

reorder statements in timeouts_get to make TIMEOUT_DISABLE_INTERVALS case simpler, removing need for macro accessors

Merge branch 'optional_intervals' of git://github.com/nmathewson/timeout into nmathewson-optional_intervals

Merge branch 'optional_timeout_ptr' of git://github.com/nmathewson/timeout into nmathewson-optional_timeout_ptr

Merge branch 'timeout_foreach' of git://github.com/nmathewson/timeout into nmathewson-timeout_foreach

Merge branch 'timeout_cb_override' of git://github.com/nmathewson/timeout into nmathewson-timeout_cb_override

Merge branch 'portable_bitops' of git://github.com/nmathewson/timeout into nmathewson-portable_bitops

According to the documentation, 32-bit x86 builds do not have the
64-bit _BitScan{Forward,Reverse}64 intrinsics.

Given these, we can remove the code to check for the zero case.

These currently cover most reachable lines and branches, except the
case where malloc fails in timeouts_open(), the if() branch in
timeouts_readd() (see issue #7) , and some failure cases in
timeouts_check().