Split time.h into time.h and timer.h.

timer.h takes the place of the old time.h, while time.h itself has been pared down to only non-async-related stuff.

Since async-io.h includes timer.h, I suspect no one will be broken by this change.

I could have instead moved the non-async parts of time.h into a new header to avoid any possibility of breakage, but time.h is the correct name for the core header, and timer.h is the correct name for the async parts (the Timer class)... so I'm risking it.

c++/Makefile.am

@@ -143,6 +143,7 @@ includekj_HEADERS =                                            \
   src/kj/async.h                                               \
   src/kj/async-inl.h                                           \
   src/kj/time.h                                                \
+  src/kj/timer.h                                               \
   src/kj/async-unix.h                                          \
   src/kj/async-win32.h                                         \
   src/kj/async-io.h                                            \
@@ -227,6 +228,7 @@ libkj_la_SOURCES=                                              \
   src/kj/io.c++                                                \
   src/kj/mutex.c++                                             \
   src/kj/thread.c++                                            \
+  src/kj/time.c++                                              \
   src/kj/test-helpers.c++                                      \
   src/kj/main.c++                                              \
   src/kj/parse/char.c++
@@ -245,7 +247,7 @@ libkj_async_la_SOURCES=                                        \
   src/kj/async-io.c++                                          \
   src/kj/async-io-unix.c++                                     \
   src/kj/async-io-win32.c++                                    \
-  src/kj/time.c++
+  src/kj/timer.c++
 
 libkj_http_la_LIBADD = libkj-async.la libkj.la $(ASYNC_LIBS) $(PTHREAD_LIBS)
 libkj_http_la_LDFLAGS = -release $(SO_VERSION) -no-undefined

c++/src/kj/CMakeLists.txt

@@ -20,6 +20,7 @@ set(kj_sources_heavy
   refcount.c++
   string-tree.c++
   encoding.c++
+  time.c++
   parse/char.c++
 )
 if(NOT CAPNP_LITE)
@@ -48,6 +49,7 @@ set(kj_headers
   mutex.h
   thread.h
   threadlocal.h
+  time.h
   main.h
   windows-sanity.h
 )
@@ -105,7 +107,7 @@ set(kj-async_sources
   async-io-win32.c++
   async-io.c++
   async-io-unix.c++
-  time.c++
+  timer.c++
 )
 set(kj-async_headers
   async-prelude.h
@@ -114,7 +116,7 @@ set(kj-async_headers
   async-unix.h
   async-win32.h
   async-io.h
-  time.h
+  timer.h
 )
 if(NOT CAPNP_LITE)
   add_library(kj-async ${kj-async_sources})

c++/src/kj/async-io.h

@@ -29,7 +29,7 @@
 #include "async.h"
 #include "function.h"
 #include "thread.h"
-#include "time.h"
+#include "timer.h"
 
 struct sockaddr;
 

c++/src/kj/async-unix.h

@@ -31,7 +31,7 @@
 #endif
 
 #include "async.h"
-#include "time.h"
+#include "timer.h"
 #include "vector.h"
 #include "io.h"
 #include <signal.h>

c++/src/kj/async-win32.h

@@ -27,7 +27,7 @@
 #endif
 
 #include "async.h"
-#include "time.h"
+#include "timer.h"
 #include "io.h"
 #include <atomic>
 #include <inttypes.h>

c++/src/kj/filesystem.c++

@@ -23,6 +23,7 @@
 #include "vector.h"
 #include "debug.h"
 #include "one-of.h"
+#include "refcount.h"
 #include <map>
 
 namespace kj {

c++/src/kj/filesystem.h

@@ -25,7 +25,7 @@
 #include "memory.h"
 #include "io.h"
 #include <inttypes.h>
-#include "time.h"  // TODO(now): problematic
+#include "time.h"
 #include "function.h"
 
 namespace kj {

c++/src/kj/time.c++

@@ -26,10 +26,6 @@
 
 namespace kj {
 
-kj::Exception Timer::makeTimeoutException() {
-  return KJ_EXCEPTION(OVERLOADED, "operation timed out");
-}
-
 Clock& nullClock() {
   class NullClock final: public Clock {
   public:
@@ -39,96 +35,4 @@ Clock& nullClock() {
   return NULL_CLOCK;
 }
 
-struct TimerImpl::Impl {
-  struct TimerBefore {
-    bool operator()(TimerPromiseAdapter* lhs, TimerPromiseAdapter* rhs);
-  };
-  using Timers = std::multiset<TimerPromiseAdapter*, TimerBefore>;
-  Timers timers;
-};
-
-class TimerImpl::TimerPromiseAdapter {
-public:
-  TimerPromiseAdapter(PromiseFulfiller<void>& fulfiller, TimerImpl::Impl& impl, TimePoint time)
-      : time(time), fulfiller(fulfiller), impl(impl) {
-    pos = impl.timers.insert(this);
-  }
-
-  ~TimerPromiseAdapter() {
-    if (pos != impl.timers.end()) {
-      impl.timers.erase(pos);
-    }
-  }
-
-  void fulfill() {
-    fulfiller.fulfill();
-    impl.timers.erase(pos);
-    pos = impl.timers.end();
-  }
-
-  const TimePoint time;
-
-private:
-  PromiseFulfiller<void>& fulfiller;
-  TimerImpl::Impl& impl;
-  Impl::Timers::const_iterator pos;
-};
-
-inline bool TimerImpl::Impl::TimerBefore::operator()(
-    TimerPromiseAdapter* lhs, TimerPromiseAdapter* rhs) {
-  return lhs->time < rhs->time;
-}
-
-Promise<void> TimerImpl::atTime(TimePoint time) {
-  return newAdaptedPromise<void, TimerPromiseAdapter>(*impl, time);
-}
-
-Promise<void> TimerImpl::afterDelay(Duration delay) {
-  return newAdaptedPromise<void, TimerPromiseAdapter>(*impl, time + delay);
-}
-
-TimerImpl::TimerImpl(TimePoint startTime)
-    : time(startTime), impl(heap<Impl>()) {}
-
-TimerImpl::~TimerImpl() noexcept(false) {}
-
-Maybe<TimePoint> TimerImpl::nextEvent() {
-  auto iter = impl->timers.begin();
-  if (iter == impl->timers.end()) {
-    return nullptr;
-  } else {
-    return (*iter)->time;
-  }
-}
-
-Maybe<uint64_t> TimerImpl::timeoutToNextEvent(TimePoint start, Duration unit, uint64_t max) {
-  return nextEvent().map([&](TimePoint nextTime) -> uint64_t {
-    if (nextTime <= start) return 0;
-
-    Duration timeout = nextTime - start;
-
-    uint64_t result = timeout / unit;
-    bool roundUp = timeout % unit > 0 * SECONDS;
-
-    if (result >= max) {
-      return max;
-    } else {
-      return result + roundUp;
-    }
-  });
-}
-
-void TimerImpl::advanceTo(TimePoint newTime) {
-  KJ_REQUIRE(newTime >= time, "can't advance backwards in time") { return; }
-
-  time = newTime;
-  for (;;) {
-    auto front = impl->timers.begin();
-    if (front == impl->timers.end() || (*front)->time > time) {
-      break;
-    }
-    (*front)->fulfill();
-  }
-}
-
 }  // namespace kj

c++/src/kj/time.h

@@ -27,7 +27,6 @@
 #pragma GCC system_header
 #endif
 
-#include "async.h"
 #include "units.h"
 #include <inttypes.h>
 
@@ -71,104 +70,6 @@ Clock& nullClock();
 // A clock which always returns UNIX_EPOCH as the current time. Useful when you don't care about
 // time.
 
-class Timer {
-  // Interface to time and timer functionality.
-  //
-  // Each `Timer` may have a different origin, and some `Timer`s may in fact tick at a different
-  // rate than real time (e.g. a `Timer` could represent CPU time consumed by a thread).  However,
-  // all `Timer`s are monotonic: time will never appear to move backwards, even if the calendar
-  // date as tracked by the system is manually modified.
-
-public:
-  virtual TimePoint now() = 0;
-  // Returns the current value of a clock that moves steadily forward, independent of any
-  // changes in the wall clock. The value is updated every time the event loop waits,
-  // and is constant in-between waits.
-
-  virtual Promise<void> atTime(TimePoint time) = 0;
-  // Returns a promise that returns as soon as now() >= time.
-
-  virtual Promise<void> afterDelay(Duration delay) = 0;
-  // Equivalent to atTime(now() + delay).
-
-  template <typename T>
-  Promise<T> timeoutAt(TimePoint time, Promise<T>&& promise) KJ_WARN_UNUSED_RESULT;
-  // Return a promise equivalent to `promise` but which throws an exception (and cancels the
-  // original promise) if it hasn't completed by `time`. The thrown exception is of type
-  // "OVERLOADED".
-
-  template <typename T>
-  Promise<T> timeoutAfter(Duration delay, Promise<T>&& promise) KJ_WARN_UNUSED_RESULT;
-  // Return a promise equivalent to `promise` but which throws an exception (and cancels the
-  // original promise) if it hasn't completed after `delay` from now. The thrown exception is of
-  // type "OVERLOADED".
-
-private:
-  static kj::Exception makeTimeoutException();
-};
-
-class TimerImpl final: public Timer {
-  // Implementation of Timer that expects an external caller -- usually, the EventPort
-  // implementation -- to tell it when time has advanced.
-
-public:
-  TimerImpl(TimePoint startTime);
-  ~TimerImpl() noexcept(false);
-
-  Maybe<TimePoint> nextEvent();
-  // Returns the time at which the next scheduled timer event will occur, or null if no timer
-  // events are scheduled.
-
-  Maybe<uint64_t> timeoutToNextEvent(TimePoint start, Duration unit, uint64_t max);
-  // Convenience method which computes a timeout value to pass to an event-waiting system call to
-  // cause it to time out when the next timer event occurs.
-  //
-  // `start` is the time at which the timeout starts counting. This is typically not the same as
-  // now() since some time may have passed since the last time advanceTo() was called.
-  //
-  // `unit` is the time unit in which the timeout is measured. This is often MILLISECONDS. Note
-  // that this method will fractional values *up*, to guarantee that the returned timeout waits
-  // until just *after* the time the event is scheduled.
-  //
-  // The timeout will be clamped to `max`. Use this to avoid an overflow if e.g. the OS wants a
-  // 32-bit value or a signed value.
-  //
-  // Returns nullptr if there are no future events.
-
-  void advanceTo(TimePoint newTime);
-  // Set the time to `time` and fire any at() events that have been passed.
-
-  // implements Timer ----------------------------------------------------------
-  TimePoint now() override;
-  Promise<void> atTime(TimePoint time) override;
-  Promise<void> afterDelay(Duration delay) override;
-
-private:
-  struct Impl;
-  class TimerPromiseAdapter;
-  TimePoint time;
-  Own<Impl> impl;
-};
-
-// =======================================================================================
-// inline implementation details
-
-template <typename T>
-Promise<T> Timer::timeoutAt(TimePoint time, Promise<T>&& promise) {
-  return promise.exclusiveJoin(atTime(time).then([]() -> kj::Promise<T> {
-    return makeTimeoutException();
-  }));
-}
-
-template <typename T>
-Promise<T> Timer::timeoutAfter(Duration delay, Promise<T>&& promise) {
-  return promise.exclusiveJoin(afterDelay(delay).then([]() -> kj::Promise<T> {
-    return makeTimeoutException();
-  }));
-}
-
-inline TimePoint TimerImpl::now() { return time; }
-
 }  // namespace kj
 
 #endif  // KJ_TIME_H_

c++/src/kj/timer.c++

+// Copyright (c) 2014 Google Inc. (contributed by Remy Blank <rblank@google.com>)
+// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
+// Licensed under the MIT License:
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#include "timer.h"
+#include "debug.h"
+#include <set>
+
+namespace kj {
+
+kj::Exception Timer::makeTimeoutException() {
+  return KJ_EXCEPTION(OVERLOADED, "operation timed out");
+}
+
+struct TimerImpl::Impl {
+  struct TimerBefore {
+    bool operator()(TimerPromiseAdapter* lhs, TimerPromiseAdapter* rhs);
+  };
+  using Timers = std::multiset<TimerPromiseAdapter*, TimerBefore>;
+  Timers timers;
+};
+
+class TimerImpl::TimerPromiseAdapter {
+public:
+  TimerPromiseAdapter(PromiseFulfiller<void>& fulfiller, TimerImpl::Impl& impl, TimePoint time)
+      : time(time), fulfiller(fulfiller), impl(impl) {
+    pos = impl.timers.insert(this);
+  }
+
+  ~TimerPromiseAdapter() {
+    if (pos != impl.timers.end()) {
+      impl.timers.erase(pos);
+    }
+  }
+
+  void fulfill() {
+    fulfiller.fulfill();
+    impl.timers.erase(pos);
+    pos = impl.timers.end();
+  }
+
+  const TimePoint time;
+
+private:
+  PromiseFulfiller<void>& fulfiller;
+  TimerImpl::Impl& impl;
+  Impl::Timers::const_iterator pos;
+};
+
+inline bool TimerImpl::Impl::TimerBefore::operator()(
+    TimerPromiseAdapter* lhs, TimerPromiseAdapter* rhs) {
+  return lhs->time < rhs->time;
+}
+
+Promise<void> TimerImpl::atTime(TimePoint time) {
+  return newAdaptedPromise<void, TimerPromiseAdapter>(*impl, time);
+}
+
+Promise<void> TimerImpl::afterDelay(Duration delay) {
+  return newAdaptedPromise<void, TimerPromiseAdapter>(*impl, time + delay);
+}
+
+TimerImpl::TimerImpl(TimePoint startTime)
+    : time(startTime), impl(heap<Impl>()) {}
+
+TimerImpl::~TimerImpl() noexcept(false) {}
+
+Maybe<TimePoint> TimerImpl::nextEvent() {
+  auto iter = impl->timers.begin();
+  if (iter == impl->timers.end()) {
+    return nullptr;
+  } else {
+    return (*iter)->time;
+  }
+}
+
+Maybe<uint64_t> TimerImpl::timeoutToNextEvent(TimePoint start, Duration unit, uint64_t max) {
+  return nextEvent().map([&](TimePoint nextTime) -> uint64_t {
+    if (nextTime <= start) return 0;
+
+    Duration timeout = nextTime - start;
+
+    uint64_t result = timeout / unit;
+    bool roundUp = timeout % unit > 0 * SECONDS;
+
+    if (result >= max) {
+      return max;
+    } else {
+      return result + roundUp;
+    }
+  });
+}
+
+void TimerImpl::advanceTo(TimePoint newTime) {
+  KJ_REQUIRE(newTime >= time, "can't advance backwards in time") { return; }
+
+  time = newTime;
+  for (;;) {
+    auto front = impl->timers.begin();
+    if (front == impl->timers.end() || (*front)->time > time) {
+      break;
+    }
+    (*front)->fulfill();
+  }
+}
+
+}  // namespace kj

c++/src/kj/timer.h

+// Copyright (c) 2014 Google Inc. (contributed by Remy Blank <rblank@google.com>)
+// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
+// Licensed under the MIT License:
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#ifndef KJ_TIMER_H_
+#define KJ_TIMER_H_
+
+#if defined(__GNUC__) && !KJ_HEADER_WARNINGS
+#pragma GCC system_header
+#endif
+
+#include "time.h"
+#include "async.h"
+
+namespace kj {
+
+class Timer {
+  // Interface to time and timer functionality.
+  //
+  // Each `Timer` may have a different origin, and some `Timer`s may in fact tick at a different
+  // rate than real time (e.g. a `Timer` could represent CPU time consumed by a thread).  However,
+  // all `Timer`s are monotonic: time will never appear to move backwards, even if the calendar
+  // date as tracked by the system is manually modified.
+
+public:
+  virtual TimePoint now() = 0;
+  // Returns the current value of a clock that moves steadily forward, independent of any
+  // changes in the wall clock. The value is updated every time the event loop waits,
+  // and is constant in-between waits.
+
+  virtual Promise<void> atTime(TimePoint time) = 0;
+  // Returns a promise that returns as soon as now() >= time.
+
+  virtual Promise<void> afterDelay(Duration delay) = 0;
+  // Equivalent to atTime(now() + delay).
+
+  template <typename T>
+  Promise<T> timeoutAt(TimePoint time, Promise<T>&& promise) KJ_WARN_UNUSED_RESULT;
+  // Return a promise equivalent to `promise` but which throws an exception (and cancels the
+  // original promise) if it hasn't completed by `time`. The thrown exception is of type
+  // "OVERLOADED".
+
+  template <typename T>
+  Promise<T> timeoutAfter(Duration delay, Promise<T>&& promise) KJ_WARN_UNUSED_RESULT;
+  // Return a promise equivalent to `promise` but which throws an exception (and cancels the
+  // original promise) if it hasn't completed after `delay` from now. The thrown exception is of
+  // type "OVERLOADED".
+
+private:
+  static kj::Exception makeTimeoutException();
+};
+
+class TimerImpl final: public Timer {
+  // Implementation of Timer that expects an external caller -- usually, the EventPort
+  // implementation -- to tell it when time has advanced.
+
+public:
+  TimerImpl(TimePoint startTime);
+  ~TimerImpl() noexcept(false);
+
+  Maybe<TimePoint> nextEvent();
+  // Returns the time at which the next scheduled timer event will occur, or null if no timer
+  // events are scheduled.
+
+  Maybe<uint64_t> timeoutToNextEvent(TimePoint start, Duration unit, uint64_t max);
+  // Convenience method which computes a timeout value to pass to an event-waiting system call to
+  // cause it to time out when the next timer event occurs.
+  //
+  // `start` is the time at which the timeout starts counting. This is typically not the same as
+  // now() since some time may have passed since the last time advanceTo() was called.
+  //
+  // `unit` is the time unit in which the timeout is measured. This is often MILLISECONDS. Note
+  // that this method will fractional values *up*, to guarantee that the returned timeout waits
+  // until just *after* the time the event is scheduled.
+  //
+  // The timeout will be clamped to `max`. Use this to avoid an overflow if e.g. the OS wants a
+  // 32-bit value or a signed value.
+  //
+  // Returns nullptr if there are no future events.
+
+  void advanceTo(TimePoint newTime);
+  // Set the time to `time` and fire any at() events that have been passed.
+
+  // implements Timer ----------------------------------------------------------
+  TimePoint now() override;
+  Promise<void> atTime(TimePoint time) override;
+  Promise<void> afterDelay(Duration delay) override;
+
+private:
+  struct Impl;
+  class TimerPromiseAdapter;
+  TimePoint time;
+  Own<Impl> impl;
+};
+
+// =======================================================================================
+// inline implementation details
+
+template <typename T>
+Promise<T> Timer::timeoutAt(TimePoint time, Promise<T>&& promise) {
+  return promise.exclusiveJoin(atTime(time).then([]() -> kj::Promise<T> {
+    return makeTimeoutException();
+  }));
+}
+
+template <typename T>
+Promise<T> Timer::timeoutAfter(Duration delay, Promise<T>&& promise) {
+  return promise.exclusiveJoin(afterDelay(delay).then([]() -> kj::Promise<T> {
+    return makeTimeoutException();
+  }));
+}
+
+inline TimePoint TimerImpl::now() { return time; }
+
+}  // namespace kj
+
+#endif  // KJ_TIMER_H_