http://bugzilla.zeroc.com/bugzilla/show_bug.cgi?id=1351 - use monotonic timers where possible

22 files changed, 128 insertions, 78 deletions

diff --git a/cpp/src/Freeze/BackgroundSaveEvictorI.cpp b/cpp/src/Freeze/BackgroundSaveEvictorI.cpp
index 0b0273fe2c5..c8a73975f11 100644
--- a/cpp/src/Freeze/BackgroundSaveEvictorI.cpp
+++ b/cpp/src/Freeze/BackgroundSaveEvictorI.cpp
@@ -269,7 +269,7 @@ Freeze::BackgroundSaveEvictorI::addFacet(const ObjectPtr& servant, const Identit
                     ObjectRecord& rec = element->rec;
 
                     rec.servant = servant;
-                    rec.stats.creationTime = IceUtil::Time::now().toMilliSeconds();
+                    rec.stats.creationTime = IceUtil::Time::now(IceUtil::Time::Monotonic).toMilliSeconds();
                     rec.stats.lastSaveTime = 0;
                     rec.stats.avgSaveTime = 0;
 
@@ -901,7 +901,7 @@ Freeze::BackgroundSaveEvictorI::run()
             
             deque<StreamedObject> streamedObjectQueue;
             
-            Long streamStart = IceUtil::Time::now().toMilliSeconds();
+            Long streamStart = IceUtil::Time::now(IceUtil::Time::Monotonic).toMilliSeconds();
             
             //
             // Stream each element
@@ -1051,7 +1051,7 @@ Freeze::BackgroundSaveEvictorI::run()
             
             if(_trace >= 1)
             {
-                Long now = IceUtil::Time::now().toMilliSeconds();
+                Long now = IceUtil::Time::now(IceUtil::Time::Monotonic).toMilliSeconds();
                 Trace out(_communicator->getLogger(), "Freeze.Evictor");
                 out << "streamed " << streamedObjectQueue.size() << " objects in " 
                     << static_cast<Int>(now - streamStart) << " ms";
@@ -1083,7 +1083,7 @@ Freeze::BackgroundSaveEvictorI::run()
                         txSize = streamedObjectQueue.size();
                     }
                     
-                    Long saveStart = IceUtil::Time::now().toMilliSeconds();
+                    Long saveStart = IceUtil::Time::now(IceUtil::Time::Monotonic).toMilliSeconds();
                     try
                     {
                         DbTxn* tx = 0;
@@ -1129,7 +1129,7 @@ Freeze::BackgroundSaveEvictorI::run()
                         
                         if(_trace >= 1)
                         {
-                            Long now = IceUtil::Time::now().toMilliSeconds();
+                            Long now = IceUtil::Time::now(IceUtil::Time::Monotonic).toMilliSeconds();
                             Trace out(_communicator->getLogger(), "Freeze.Evictor");
                             out << "saved " << txSize << " objects in " 
                                 << static_cast<Int>(now - saveStart) << " ms";
diff --git a/cpp/src/Freeze/TransactionalEvictorContext.cpp b/cpp/src/Freeze/TransactionalEvictorContext.cpp
index 9fe1cf11d3f..369c6fd1763 100644
--- a/cpp/src/Freeze/TransactionalEvictorContext.cpp
+++ b/cpp/src/Freeze/TransactionalEvictorContext.cpp
@@ -223,7 +223,8 @@ Freeze::TransactionalEvictorContext::ServantHolder::~ServantHolder()
         {
             if(!_body.readOnly && !_body.removed)
             {
-                EvictorIBase::updateStats(_body.rec.stats, IceUtil::Time::now().toMilliSeconds());
+                EvictorIBase::updateStats(_body.rec.stats, 
+                                          IceUtil::Time::now(IceUtil::Time::Monotonic).toMilliSeconds());
                 _body.store->update(_body.current->id, _body.rec, ctx->_tx);
             }
         
diff --git a/cpp/src/Freeze/TransactionalEvictorI.cpp b/cpp/src/Freeze/TransactionalEvictorI.cpp
index eb359c22368..5ce3ed9dab6 100644
--- a/cpp/src/Freeze/TransactionalEvictorI.cpp
+++ b/cpp/src/Freeze/TransactionalEvictorI.cpp
@@ -138,7 +138,7 @@ Freeze::TransactionalEvictorI::addFacet(const ObjectPtr& servant, const Identity
     checkIdentity(ident);
     DeactivateController::Guard deactivateGuard(_deactivateController);
    
-    Ice::Long currentTime = IceUtil::Time::now().toMilliSeconds();
+    Ice::Long currentTime = IceUtil::Time::now(IceUtil::Time::Monotonic).toMilliSeconds();
 
     Statistics stats = { currentTime };
     ObjectRecord rec;
diff --git a/cpp/src/Glacier2/RequestQueue.cpp b/cpp/src/Glacier2/RequestQueue.cpp
index 099b73f3640..399884cf2f2 100644
--- a/cpp/src/Glacier2/RequestQueue.cpp
+++ b/cpp/src/Glacier2/RequestQueue.cpp
@@ -352,14 +352,14 @@ Glacier2::RequestQueue::run()
             {
                 if(_sleep)
                 {
-                    IceUtil::Time now = IceUtil::Time::now();
+                    IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic);
                     if(!timedWait(_sleepDuration))
                     {
                         _sleepDuration = IceUtil::Time();
                     }
                     else
                     {
-                        _sleepDuration -= IceUtil::Time::now() - now;
+                        _sleepDuration -= IceUtil::Time::now(IceUtil::Time::Monotonic) - now;
                     }
                     if(_sleepDuration <= IceUtil::Time())
                     {
diff --git a/cpp/src/Glacier2/RouterI.cpp b/cpp/src/Glacier2/RouterI.cpp
index ff917e8b445..ee6dde8edd4 100644
--- a/cpp/src/Glacier2/RouterI.cpp
+++ b/cpp/src/Glacier2/RouterI.cpp
@@ -30,7 +30,7 @@ Glacier2::RouterI::RouterI(const ObjectAdapterPtr& clientAdapter, const ObjectAd
     _session(session),
     _controlId(controlId),
     _sslContext(sslContext),
-    _timestamp(IceUtil::Time::now())
+    _timestamp(IceUtil::Time::now(IceUtil::Time::Monotonic))
 {
     //
     // If Glacier2 will be used with pre 3.2 clients, then the client proxy must be set.
@@ -142,7 +142,7 @@ Glacier2::RouterI::addProxies(const ObjectProxySeq& proxies, const Current& curr
 {
     IceUtil::Mutex::Lock lock(*this);
 
-    _timestamp = IceUtil::Time::now();
+    _timestamp = IceUtil::Time::now(IceUtil::Time::Monotonic);
 
     return _clientBlobject->add(proxies, current);
 }
@@ -186,7 +186,7 @@ Glacier2::RouterI::getClientBlobject() const
 {
     IceUtil::Mutex::Lock lock(*this);
 
-    _timestamp = IceUtil::Time::now();
+    _timestamp = IceUtil::Time::now(IceUtil::Time::Monotonic);
 
     return _clientBlobject;
 }
@@ -219,7 +219,7 @@ Glacier2::RouterI::getTimestamp() const
     }
     else
     {
-        return IceUtil::Time::now();
+        return IceUtil::Time::now(IceUtil::Time::Monotonic);
     }
 }
 
diff --git a/cpp/src/Glacier2/SessionRouterI.cpp b/cpp/src/Glacier2/SessionRouterI.cpp
index 642f4f527f7..95945659800 100644
--- a/cpp/src/Glacier2/SessionRouterI.cpp
+++ b/cpp/src/Glacier2/SessionRouterI.cpp
@@ -641,7 +641,7 @@ Glacier2::SessionRouterI::expireSessions()
         }
         
         assert(_sessionTimeout > IceUtil::Time());
-        IceUtil::Time minTimestamp = IceUtil::Time::now() - _sessionTimeout;
+        IceUtil::Time minTimestamp = IceUtil::Time::now(IceUtil::Time::Monotonic) - _sessionTimeout;
         
         map<ConnectionPtr, RouterIPtr>::iterator p = _routersByConnection.begin();
         
diff --git a/cpp/src/Ice/ConnectionI.cpp b/cpp/src/Ice/ConnectionI.cpp
index 69d8d52206b..cdf3dce6b80 100644
--- a/cpp/src/Ice/ConnectionI.cpp
+++ b/cpp/src/Ice/ConnectionI.cpp
@@ -216,7 +216,7 @@ Ice::ConnectionI::validate()
         
         if(_acmTimeout > 0)
         {
-            _acmAbsoluteTimeout = IceUtil::Time::now() + IceUtil::Time::seconds(_acmTimeout);
+            _acmAbsoluteTimeout = IceUtil::Time::now(IceUtil::Time::Monotonic) + IceUtil::Time::seconds(_acmTimeout);
         }
         
         //
@@ -407,7 +407,7 @@ Ice::ConnectionI::waitUntilFinished()
             if(_state != StateClosed && _endpoint->timeout() >= 0)
             {
                 IceUtil::Time timeout = IceUtil::Time::milliSeconds(_endpoint->timeout());
-                IceUtil::Time waitTime = _stateTime + timeout - IceUtil::Time::now();
+                IceUtil::Time waitTime = _stateTime + timeout - IceUtil::Time::now(IceUtil::Time::Monotonic);
                 
                 if(waitTime > IceUtil::Time())
                 {
@@ -477,7 +477,7 @@ Ice::ConnectionI::monitor()
     //
     for(map<Int, AsyncRequest>::iterator p = _asyncRequests.begin(); p != _asyncRequests.end(); ++p)
     {
-        if(p->second.t > IceUtil::Time() && p->second.t <= IceUtil::Time::now())
+        if(p->second.t > IceUtil::Time() && p->second.t <= IceUtil::Time::now(IceUtil::Time::Monotonic))
         {
             setState(StateClosed, TimeoutException(__FILE__, __LINE__));
             return;
@@ -492,7 +492,7 @@ Ice::ConnectionI::monitor()
        !_batchStreamInUse && _batchStream.b.empty() &&
        _dispatchCount == 0)
     {
-        if(IceUtil::Time::now() >= _acmAbsoluteTimeout)
+        if(IceUtil::Time::now(IceUtil::Time::Monotonic) >= _acmAbsoluteTimeout)
         {
             setState(StateClosing, ConnectionTimeoutException(__FILE__, __LINE__));
             return;
@@ -556,7 +556,7 @@ Ice::ConnectionI::sendRequest(BasicStream* os, Outgoing* out, bool compress)
                 
         if(_acmTimeout > 0)
         {
-            _acmAbsoluteTimeout = IceUtil::Time::now() + IceUtil::Time::seconds(_acmTimeout);
+            _acmAbsoluteTimeout = IceUtil::Time::now(IceUtil::Time::Monotonic) + IceUtil::Time::seconds(_acmTimeout);
         }
     }
 
@@ -715,14 +715,15 @@ Ice::ConnectionI::sendAsyncRequest(BasicStream* os, const OutgoingAsyncPtr& out,
         asyncRequest.p = out;
         if(_endpoint->timeout() > 0)
         {
-            asyncRequest.t = IceUtil::Time::now() + IceUtil::Time::milliSeconds(_endpoint->timeout());
+            asyncRequest.t = 
+                IceUtil::Time::now(IceUtil::Time::Monotonic) + IceUtil::Time::milliSeconds(_endpoint->timeout());
         }
         _asyncRequestsHint = _asyncRequests.insert(_asyncRequests.end(),
                                                    pair<const Int, AsyncRequest>(requestId, asyncRequest));
         
         if(_acmTimeout > 0)
         {
-            _acmAbsoluteTimeout = IceUtil::Time::now() + IceUtil::Time::seconds(_acmTimeout);
+            _acmAbsoluteTimeout = IceUtil::Time::now(IceUtil::Time::Monotonic) + IceUtil::Time::seconds(_acmTimeout);
         }
     }
 
@@ -1037,7 +1038,7 @@ Ice::ConnectionI::flushBatchRequestsInternal(bool ignoreInUse)
 
         if(_acmTimeout > 0)
         {
-            _acmAbsoluteTimeout = IceUtil::Time::now() + IceUtil::Time::seconds(_acmTimeout);
+            _acmAbsoluteTimeout = IceUtil::Time::now(IceUtil::Time::Monotonic) + IceUtil::Time::seconds(_acmTimeout);
         }
 
         //
@@ -1253,7 +1254,8 @@ Ice::ConnectionI::sendResponse(BasicStream* os, Byte compressFlag)
             
             if(_acmTimeout > 0)
             {
-                _acmAbsoluteTimeout = IceUtil::Time::now() + IceUtil::Time::seconds(_acmTimeout);
+                _acmAbsoluteTimeout = 
+                    IceUtil::Time::now(IceUtil::Time::Monotonic) + IceUtil::Time::seconds(_acmTimeout);
             }
         }
         catch(const LocalException& ex)
@@ -1596,7 +1598,7 @@ Ice::ConnectionI::ConnectionI(const InstancePtr& instance,
     _batchMarker(0),
     _dispatchCount(0),
     _state(StateNotValidated),
-    _stateTime(IceUtil::Time::now())
+    _stateTime(IceUtil::Time::now(IceUtil::Time::Monotonic))
 {
     Int& acmTimeout = const_cast<Int&>(_acmTimeout);
     if(_endpoint->datagram())
@@ -1944,7 +1946,7 @@ Ice::ConnectionI::setState(State state)
     }
 
     _state = state;
-    _stateTime = IceUtil::Time::now();
+    _stateTime = IceUtil::Time::now(IceUtil::Time::Monotonic);
 
     notifyAll();
 
@@ -2184,7 +2186,7 @@ Ice::ConnectionI::parseMessage(BasicStream& stream, Int& invokeNum, Int& request
     
     if(_acmTimeout > 0)
     {
-        _acmAbsoluteTimeout = IceUtil::Time::now() + IceUtil::Time::seconds(_acmTimeout);
+        _acmAbsoluteTimeout = IceUtil::Time::now(IceUtil::Time::Monotonic) + IceUtil::Time::seconds(_acmTimeout);
     }
     
     try
diff --git a/cpp/src/Ice/GC.cpp b/cpp/src/Ice/GC.cpp
index 605997439a5..80fab03aa3f 100755
--- a/cpp/src/Ice/GC.cpp
+++ b/cpp/src/Ice/GC.cpp
@@ -268,7 +268,7 @@ IceInternal::GC::collectGarbage()
 
     if(_statsCallback)
     {
-        t = Time::now();
+        t = Time::now(IceUtil::Time::Monotonic);
         stats.examined = static_cast<int>(gcObjects.size());
     }
 
@@ -367,7 +367,7 @@ IceInternal::GC::collectGarbage()
 
     if(_statsCallback)
     {
-        stats.time = Time::now() - t;
+        stats.time = Time::now(IceUtil::Time::Monotonic) - t;
         stats.collected = static_cast<int>(counts.size());
         _statsCallback(stats);
     }
diff --git a/cpp/src/Ice/LocatorInfo.cpp b/cpp/src/Ice/LocatorInfo.cpp
index b7a99ba1cb4..606d7557fdd 100644
--- a/cpp/src/Ice/LocatorInfo.cpp
+++ b/cpp/src/Ice/LocatorInfo.cpp
@@ -144,11 +144,12 @@ IceInternal::LocatorTable::addAdapterEndpoints(const string& adapter, const vect
     
     if(p != _adapterEndpointsMap.end())
     {
-        p->second = make_pair(IceUtil::Time::now(), endpoints);
+        p->second = make_pair(IceUtil::Time::now(IceUtil::Time::Monotonic), endpoints);
     }
     else
     {
-        _adapterEndpointsMap.insert(make_pair(adapter, make_pair(IceUtil::Time::now(), endpoints)));
+        _adapterEndpointsMap.insert(
+            make_pair(adapter, make_pair(IceUtil::Time::now(IceUtil::Time::Monotonic), endpoints)));
     }
 }
 
@@ -199,11 +200,11 @@ IceInternal::LocatorTable::addProxy(const Identity& id, const ObjectPrx& proxy)
     
     if(p != _objectMap.end())
     {
-        p->second = make_pair(IceUtil::Time::now(), proxy);
+        p->second = make_pair(IceUtil::Time::now(IceUtil::Time::Monotonic), proxy);
     }
     else
     {
-        _objectMap.insert(make_pair(id, make_pair(IceUtil::Time::now(), proxy)));
+        _objectMap.insert(make_pair(id, make_pair(IceUtil::Time::now(IceUtil::Time::Monotonic), proxy)));
     }
 }
 
@@ -233,7 +234,7 @@ IceInternal::LocatorTable::checkTTL(const IceUtil::Time& time, int ttl) const
     }
     else
     {
-        return IceUtil::Time::now() - time <= IceUtil::Time::seconds(ttl);
+        return IceUtil::Time::now(IceUtil::Time::Monotonic) - time <= IceUtil::Time::seconds(ttl);
     }
 }
 
diff --git a/cpp/src/IceGrid/Allocatable.cpp b/cpp/src/IceGrid/Allocatable.cpp
index bcf1e5b17ef..05f48d70311 100644
--- a/cpp/src/IceGrid/Allocatable.cpp
+++ b/cpp/src/IceGrid/Allocatable.cpp
@@ -38,7 +38,8 @@ AllocationRequest::pending()
 
     if(_timeout > 0)
     {
-        _session->getTimer()->schedule(this, IceUtil::Time::now() + IceUtil::Time::milliSeconds(_timeout));
+        _session->getTimer()->schedule(this, IceUtil::Time::now(IceUtil::Time::Monotonic) +
+                                       IceUtil::Time::milliSeconds(_timeout));
     }
     _state = Pending;
     return true;
diff --git a/cpp/src/IceGrid/NodeSessionI.cpp b/cpp/src/IceGrid/NodeSessionI.cpp
index 6d12869379e..49a46ef1959 100644
--- a/cpp/src/IceGrid/NodeSessionI.cpp
+++ b/cpp/src/IceGrid/NodeSessionI.cpp
@@ -141,7 +141,7 @@ NodeSessionI::NodeSessionI(const DatabasePtr& database,
     _node(node),
     _info(info),
     _timeout(timeout),
-    _timestamp(IceUtil::Time::now()),
+    _timestamp(IceUtil::Time::now(IceUtil::Time::Monotonic)),
     _load(load),
     _destroy(false)
 {
@@ -189,7 +189,7 @@ NodeSessionI::keepAlive(const LoadInfo& load, const Ice::Current& current)
         throw Ice::ObjectNotExistException(__FILE__, __LINE__);
     }
 
-    _timestamp = IceUtil::Time::now();
+    _timestamp = IceUtil::Time::now(IceUtil::Time::Monotonic);
     _load = load;
 
     if(_traceLevels->node > 2)
diff --git a/cpp/src/IceGrid/ReapThread.cpp b/cpp/src/IceGrid/ReapThread.cpp
index 06869232b6e..9034a6f18f8 100644
--- a/cpp/src/IceGrid/ReapThread.cpp
+++ b/cpp/src/IceGrid/ReapThread.cpp
@@ -57,7 +57,7 @@ ReapThread::run()
             {
                 try
                 {
-                    if((IceUtil::Time::now() - p->item->timestamp()) > p->timeout)
+                    if((IceUtil::Time::now(IceUtil::Time::Monotonic) - p->item->timestamp()) > p->timeout)
                     {
                         reap.push_back(*p);
                         p = _sessions.erase(p);
diff --git a/cpp/src/IceGrid/ReplicaSessionI.cpp b/cpp/src/IceGrid/ReplicaSessionI.cpp
index 6de154a0ee5..110e9b6d46e 100644
--- a/cpp/src/IceGrid/ReplicaSessionI.cpp
+++ b/cpp/src/IceGrid/ReplicaSessionI.cpp
@@ -39,7 +39,7 @@ ReplicaSessionI::ReplicaSessionI(const DatabasePtr& database,
     _internalRegistry(proxy),
     _info(info),
     _timeout(timeout),
-    _timestamp(IceUtil::Time::now()),
+    _timestamp(IceUtil::Time::now(IceUtil::Time::Monotonic)),
     _destroy(false)
 {
     __setNoDelete(true);
@@ -79,7 +79,7 @@ ReplicaSessionI::keepAlive(const Ice::Current& current)
         throw Ice::ObjectNotExistException(__FILE__, __LINE__);
     }
 
-    _timestamp = IceUtil::Time::now();
+    _timestamp = IceUtil::Time::now(IceUtil::Time::Monotonic);
 
     if(_traceLevels->replica > 2)
     {
diff --git a/cpp/src/IceGrid/ServerI.cpp b/cpp/src/IceGrid/ServerI.cpp
index 5e4a03e02cb..0ec35344f6e 100644
--- a/cpp/src/IceGrid/ServerI.cpp
+++ b/cpp/src/IceGrid/ServerI.cpp
@@ -346,7 +346,7 @@ void
 TimedServerCommand::startTimer()
 {
     _timerTask = new CommandTimeoutTimerTask(this);
-    _timer->schedule(_timerTask, IceUtil::Time::now() + IceUtil::Time::seconds(_timeout));
+    _timer->schedule(_timerTask, IceUtil::Time::now(IceUtil::Time::Monotonic) + IceUtil::Time::seconds(_timeout));
 }
 
 void
@@ -654,7 +654,7 @@ ServerI::ServerI(const NodeIPtr& node, const ServerPrx& proxy, const string& ser
     _disableOnFailure(0),
     _state(ServerI::Inactive),
     _activation(ServerI::Disabled),
-    _failureTime(IceUtil::Time::now()), // Ensure that _activation gets initialized in updateImpl().
+    _failureTime(IceUtil::Time::now(IceUtil::Time::Monotonic)), // Ensure that _activation gets initialized in updateImpl().
     _pid(0)
 {
     assert(_node->getActivator());
@@ -895,7 +895,8 @@ ServerI::start(ServerActivation activation, const AMD_Server_startPtr& amdCB)
         if(_disableOnFailure > 0 && _failureTime != IceUtil::Time())
         {
             if(activation == Manual ||
-               (_failureTime + IceUtil::Time::seconds(_disableOnFailure) < IceUtil::Time::now()))
+               (_failureTime + IceUtil::Time::seconds(_disableOnFailure) < 
+                IceUtil::Time::now(IceUtil::Time::Monotonic)))
             {
                 _activation = _previousActivation;
                 _failureTime = IceUtil::Time();
@@ -1197,7 +1198,7 @@ ServerI::disableOnFailure()
     {
         _previousActivation = _activation;
         _activation = Disabled;
-        _failureTime = IceUtil::Time::now();
+        _failureTime = IceUtil::Time::now(IceUtil::Time::Monotonic);
     }
 }
 
@@ -1210,7 +1211,8 @@ ServerI::enableAfterFailure(bool force)
     }
 
     if(force ||
-       _disableOnFailure > 0 && (_failureTime + IceUtil::Time::seconds(_disableOnFailure) < IceUtil::Time::now()))
+       _disableOnFailure > 0 && 
+       (_failureTime + IceUtil::Time::seconds(_disableOnFailure) < IceUtil::Time::now(IceUtil::Time::Monotonic)))
     {
         _activation = _previousActivation;
         _failureTime = IceUtil::Time();
@@ -2451,7 +2453,8 @@ ServerI::setStateNoSync(InternalServerState st, const std::string& reason)
         if(_activation == Always)
         {
             _timerTask = new DelayedStart(this, _node->getTraceLevels());
-            _node->getTimer()->schedule(_timerTask, IceUtil::Time::now() + IceUtil::Time::milliSeconds(500));
+            _node->getTimer()->schedule(_timerTask, IceUtil::Time::now(IceUtil::Time::Monotonic) + 
+                                        IceUtil::Time::milliSeconds(500));
         }
         else if(_activation == Disabled && _disableOnFailure > 0 && _failureTime != IceUtil::Time())
         {
@@ -2463,8 +2466,8 @@ ServerI::setStateNoSync(InternalServerState st, const std::string& reason)
             // callback is executed.  
             //
             _timerTask = new DelayedStart(this, _node->getTraceLevels());
-            _node->getTimer()->schedule(_timerTask, IceUtil::Time::now() + IceUtil::Time::seconds(_disableOnFailure) + 
-                                        IceUtil::Time::milliSeconds(500));
+            _node->getTimer()->schedule(_timerTask, IceUtil::Time::now(IceUtil::Time::Monotonic) +
+                                        IceUtil::Time::seconds(_disableOnFailure) + IceUtil::Time::milliSeconds(500));
         }
     }
 
diff --git a/cpp/src/IceGrid/SessionI.cpp b/cpp/src/IceGrid/SessionI.cpp
index 694ed50bff5..44241b8697b 100644
--- a/cpp/src/IceGrid/SessionI.cpp
+++ b/cpp/src/IceGrid/SessionI.cpp
@@ -74,7 +74,7 @@ BaseSessionI::BaseSessionI(const string& id,
     _database(database),
     _filters(filters),
     _destroyed(false),
-    _timestamp(IceUtil::Time::now())
+    _timestamp(IceUtil::Time::now(IceUtil::Time::Monotonic))
 {
     if(_traceLevels && _traceLevels->session > 0)
     {
@@ -98,7 +98,7 @@ BaseSessionI::keepAlive(const Ice::Current& current)
         throw ex;
     }
 
-    _timestamp = IceUtil::Time::now();
+    _timestamp = IceUtil::Time::now(IceUtil::Time::Monotonic);
 
     if(_traceLevels->session > 1)
     {
diff --git a/cpp/src/IceGrid/WaitQueue.cpp b/cpp/src/IceGrid/WaitQueue.cpp
index 06e18766558..93c294d0018 100644
--- a/cpp/src/IceGrid/WaitQueue.cpp
+++ b/cpp/src/IceGrid/WaitQueue.cpp
@@ -61,7 +61,7 @@ WaitQueue::run()
             while(!_waitQueue.empty() && !_destroyed)
             {
                 WaitItemPtr item = _waitQueue.front();              
-                if(item->getExpirationTime() <= IceUtil::Time::now())
+                if(item->getExpirationTime() <= IceUtil::Time::now(IceUtil::Time::Monotonic))
                 {
                     expired.push_back(item);
                     _waitQueue.pop_front();     
@@ -76,7 +76,7 @@ WaitQueue::run()
                     // Wait until the next item expire or a notification. Note: in any case we 
                     // get out of this loop to get a chance to execute the work queue.
                     //
-                    timedWait(item->getExpirationTime() - IceUtil::Time::now());                            
+                    timedWait(item->getExpirationTime() - IceUtil::Time::now(IceUtil::Time::Monotonic));
                 }
             }
         }
@@ -140,7 +140,7 @@ WaitQueue::add(const WaitItemPtr& item, const IceUtil::Time& wait)
     //
     bool notifyThread = _waitQueue.empty();
 
-    IceUtil::Time expire = IceUtil::Time::now() + wait;
+    IceUtil::Time expire = IceUtil::Time::now(IceUtil::Time::Monotonic) + wait;
     item->setExpirationTime(expire);
     
     list<WaitItemPtr>::iterator p = _waitQueue.begin();
diff --git a/cpp/src/IceStorm/Subscriber.cpp b/cpp/src/IceStorm/Subscriber.cpp
index 7eab249578e..b7e5ef45aa9 100644
--- a/cpp/src/IceStorm/Subscriber.cpp
+++ b/cpp/src/IceStorm/Subscriber.cpp
@@ -613,7 +613,7 @@ SubscriberLink::queue(bool forwarded, const EventDataSeq& events)
         // forwarded argument an EventInfo thing where the queue-time
         // is lazy initialized.
         //
-        if(IceUtil::Time::now() < _next)
+        if(IceUtil::Time::now(IceUtil::Time::Monotonic) < _next)
         {
             return QueueStateNoFlush;
         }
@@ -713,7 +713,7 @@ SubscriberLink::offline(const Ice::Exception& e)
     IceUtil::Mutex::Lock sync(_mutex);
     assert(_state != SubscriberStateOffline);
 
-    _next = IceUtil::Time::now() + _instance->discardInterval();
+    _next = IceUtil::Time::now(IceUtil::Time::Monotonic) + _instance->discardInterval();
 
     TraceLevelsPtr traceLevels = _instance->traceLevels();
     if(_warn)
diff --git a/cpp/src/IceStorm/SubscriberPool.cpp b/cpp/src/IceStorm/SubscriberPool.cpp
index 8fcbb75d4b1..254b99b4ae6 100644
--- a/cpp/src/IceStorm/SubscriberPool.cpp
+++ b/cpp/src/IceStorm/SubscriberPool.cpp
@@ -58,9 +58,9 @@ public:
             //
             if(computeInterval)
             {
-                IceUtil::Time start = IceUtil::Time::now();
+                IceUtil::Time start = IceUtil::Time::now(IceUtil::Time::Monotonic);
                 requeue = sub->flush();
-                interval = IceUtil::Time::now() - start;
+                interval = IceUtil::Time::now(IceUtil::Time::Monotonic) - start;
             }
             else
             {
@@ -350,7 +350,7 @@ SubscriberPool::dequeue(SubscriberPtr& subscriber, bool requeue, const IceUtil::
         //
         if(_workers.size() > _size)
         {
-            IceUtil::Time now = IceUtil::Time::now();
+            IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic);
             if(now - _lastStallCheck > _stallCheck)
             {
                 _lastStallCheck = now;
@@ -398,7 +398,7 @@ SubscriberPool::dequeue(SubscriberPtr& subscriber, bool requeue, const IceUtil::
         return;
     }
 
-    _lastDequeue = IceUtil::Time::now();
+    _lastDequeue = IceUtil::Time::now(IceUtil::Time::Monotonic);
 
     subscriber = _pending.front();
     _pending.pop_front();
@@ -475,7 +475,7 @@ SubscriberPool::check()
         return;
     }
 
-    IceUtil::Time now = IceUtil::Time::now();
+    IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic);
     IceUtil::Time interval = now - _lastDequeue;
 /*
     if(_traceLevels->subscriberPool > 1)
diff --git a/cpp/src/IceUtil/Cond.cpp b/cpp/src/IceUtil/Cond.cpp
index f53d338191c..f1c24099eb8 100644
--- a/cpp/src/IceUtil/Cond.cpp
+++ b/cpp/src/IceUtil/Cond.cpp
@@ -302,6 +302,14 @@ IceUtil::Cond::Cond()
         throw ThreadSyscallException(__FILE__, __LINE__, rc);
     }
 
+#if !defined(__hpux) && !defined(__APPLE__)
+    rc = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC); 
+    if(rc != 0)
+    {
+        throw ThreadSyscallException(__FILE__, __LINE__, rc);
+    }
+#endif
+
     rc = pthread_cond_init(&_cond, &attr);
     if(rc != 0)
     {
diff --git a/cpp/src/IceUtil/RWRecMutex.cpp b/cpp/src/IceUtil/RWRecMutex.cpp
index d15d4acd98c..8f07a0dc1f0 100644
--- a/cpp/src/IceUtil/RWRecMutex.cpp
+++ b/cpp/src/IceUtil/RWRecMutex.cpp
@@ -89,10 +89,10 @@ IceUtil::RWRecMutex::timedReadLock(const Time& timeout) const
     // Wait while a writer holds the lock or while writers or an upgrader
     // are waiting to get the lock.
     //
-    Time end = Time::now() + timeout;
+    Time end = Time::now(Time::Monotonic) + timeout;
     while(_count < 0 || _waitingWriters != 0)
     {
-        Time remainder = end - Time::now();
+        Time remainder = end - Time::now(Time::Monotonic);
         if(remainder > Time())
         {
             if(_readers.timedWait(lock, remainder) == false)
@@ -200,10 +200,10 @@ IceUtil::RWRecMutex::timedWriteLock(const Time& timeout) const
     // Wait for the lock to become available and increment the number
     // of waiting writers.
     //
-    Time end = Time::now() + timeout;
+    Time end = Time::now(Time::Monotonic) + timeout;
     while(_count != 0)
     {
-        Time remainder = end - Time::now();
+        Time remainder = end - Time::now(Time::Monotonic);
         if(remainder > Time())
         {
             ++_waitingWriters;
@@ -382,10 +382,10 @@ IceUtil::RWRecMutex::timedUpgrade(const Time& timeout) const
     // Wait to acquire the write lock.
     //
     _upgrading = true;
-    Time end = Time::now() + timeout;
+    Time end = Time::now(Time::Monotonic) + timeout;
     while(_count != 0)
     {
-        Time remainder = end - Time::now();
+        Time remainder = end - Time::now(Time::Monotonic);
         if(remainder > Time())
         {
             ++_waitingWriters;
diff --git a/cpp/src/IceUtil/Time.cpp b/cpp/src/IceUtil/Time.cpp
index c39c2bcf53e..d562d7a72b4 100644
--- a/cpp/src/IceUtil/Time.cpp
+++ b/cpp/src/IceUtil/Time.cpp
@@ -25,24 +25,58 @@ Time::Time() :
 {
 }
 
+#ifdef _WIN32
+Int64 IceUtil::Time::_frequency = -1;
+#endif
+
 Time
-IceUtil::Time::now()
+IceUtil::Time::now(Clock clock)
 {
+    if(clock == Realtime)
+    {
 #ifdef _WIN32
 #  if defined(_MSC_VER)
-    struct _timeb tb;
-    _ftime(&tb);
+        struct _timeb tb;
+        _ftime(&tb);
 #  elif defined(__BCPLUSPLUS__)
-    struct timeb tb;
-    ftime(&tb);
+        struct timeb tb;
+        ftime(&tb);
 #  endif
-    return Time(static_cast<Int64>(tb.time) * ICE_INT64(1000000) + 
-                tb.millitm * 1000);
+        return Time(static_cast<Int64>(tb.time) * ICE_INT64(1000000) + 
+                    tb.millitm * 1000);
 #else
-    struct timeval tv;
-    gettimeofday(&tv, 0);
-    return Time(tv.tv_sec * ICE_INT64(1000000) + tv.tv_usec);
+        struct timeval tv;
+        gettimeofday(&tv, 0);
+        return Time(tv.tv_sec * ICE_INT64(1000000) + tv.tv_usec);
 #endif
+    }
+    else // Monotonic
+    {
+#if defined(_WIN32)
+        if(_frequency == -1)
+        {
+            //
+            // Frequency cannot change while machine is running so it
+            // only needs to be retrieved once.
+            //
+            QueryPerformanceFrequency((LARGE_INTEGER*)&_frequency);
+        }
+        Int64 count;
+        QueryPerformanceCounter((LARGE_INTEGER*)&count);
+        return Time((Int64)(1000000.0 / _frequency * count));
+#elif defined(__hpux) || defined(__APPLE__)
+        //
+        // HP/MacOS does not support CLOCK_MONOTONIC
+        //
+        struct timeval tv;
+        gettimeofday(&tv, 0);
+        return Time(tv.tv_sec * ICE_INT64(1000000) + tv.tv_usec);
+#else
+        struct timespec ts;
+        clock_gettime(CLOCK_MONOTONIC, &ts);
+        return Time(ts.tv_sec * ICE_INT64(1000000) + ts.tv_nsec / ICE_INT64(1000));
+#endif
+    }
 }
 
 Time
diff --git a/cpp/src/IceUtil/Timer.cpp b/cpp/src/IceUtil/Timer.cpp
index d08a35fea03..fd80db92f2c 100755
--- a/cpp/src/IceUtil/Timer.cpp
+++ b/cpp/src/IceUtil/Timer.cpp
@@ -72,7 +72,7 @@ Timer::scheduleRepeated(const TimerTaskPtr& task, const IceUtil::Time& delay)
         return;
     }
 
-    const Token token(IceUtil::Time::now() + delay, delay, task);
+    const Token token(IceUtil::Time::now(IceUtil::Time::Monotonic) + delay, delay, task);
     bool inserted = _tasks.insert(make_pair(task, token.scheduledTime)).second;
     if(!inserted)
     {
@@ -127,7 +127,7 @@ Timer::run()
                     map<TimerTaskPtr, IceUtil::Time>::iterator p = _tasks.find(token.task);
                     if(p != _tasks.end())
                     {
-                        token.scheduledTime = IceUtil::Time::now() + token.delay;
+                        token.scheduledTime = IceUtil::Time::now(IceUtil::Time::Monotonic) + token.delay;
                         p->second = token.scheduledTime;
                         _tokens.insert(token);
                     }
@@ -148,7 +148,7 @@ Timer::run()
             
             while(!_tokens.empty() && !_destroyed)
             {
-                const IceUtil::Time now = IceUtil::Time::now();
+                const IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic);
                 const Token& first = *(_tokens.begin());
                 if(first.scheduledTime <= now)
                 {