zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/Timer.cpp

@@ -1,190 +1,101 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <IceUtil/Timer.h>
-#include <IceUtil/Exception.h>
-#include <Ice/ConsoleUtil.h>
+#include "Timer.h"
+#include "ConsoleUtil.h"
+#include "Ice/Exception.h"
 
 using namespace std;
-using namespace IceUtil;
+using namespace Ice;
 using namespace IceInternal;
 
-TimerTask::~TimerTask()
-{
-    // Out of line to avoid weak vtable
-}
+TimerTask::~TimerTask() = default; // Out of line to avoid weak vtable
 
-Timer::Timer() :
-    Thread("IceUtil timer thread"),
-    _destroyed(false)
-{
-    __setNoDelete(true);
-    start();
-    __setNoDelete(false);
-}
-
-Timer::Timer(int priority) :
-    Thread("IceUtil timer thread"),
-    _destroyed(false)
-{
-    __setNoDelete(true);
-    start(0, priority);
-    __setNoDelete(false);
-}
+Timer::Timer() : _wakeUpTime(chrono::steady_clock::time_point()), _worker(&Timer::run, this) {}
 
 void
 Timer::destroy()
 {
+    if (std::this_thread::get_id() == _worker.get_id())
+    {
+        throw std::runtime_error("a timer task cannot destroy the timer");
+    }
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
-        if(_destroyed)
+        std::lock_guard lock(_mutex);
+        if (_destroyed)
         {
             return;
         }
         _destroyed = true;
-        _monitor.notify();
         _tasks.clear();
         _tokens.clear();
+        _condition.notify_one();
     }
-
-    if(getThreadControl() == ThreadControl())
-    {
-        getThreadControl().detach();
-    }
-    else
-    {
-        getThreadControl().join();
-    }
+    _worker.join();
 }
 
-void
-Timer::schedule(const TimerTaskPtr& task, const IceUtil::Time& delay)
+bool
+Timer::cancel(const TimerTaskPtr& task) noexcept
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
-    if(_destroyed)
-    {
-        throw IllegalArgumentException(__FILE__, __LINE__, "timer destroyed");
-    }
-
-    IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic);
-    IceUtil::Time time = now + delay;
-    if(delay > IceUtil::Time() && time < now)
-    {
-        throw IllegalArgumentException(__FILE__, __LINE__, "invalid delay");
-    }
-
-    bool inserted = _tasks.insert(make_pair(task, time)).second;
-    if(!inserted)
-    {
-        throw IllegalArgumentException(__FILE__, __LINE__, "task is already scheduled");
-    }
-    _tokens.insert(Token(time, IceUtil::Time(), task));
-
-    if(_wakeUpTime == IceUtil::Time() || time < _wakeUpTime)
-    {
-        _monitor.notify();
-    }
-}
-
-void
-Timer::scheduleRepeated(const TimerTaskPtr& task, const IceUtil::Time& delay)
-{
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
-    if(_destroyed)
-    {
-        throw IllegalArgumentException(__FILE__, __LINE__, "timer destroyed");
-    }
-
-    IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic);
-    const Token token(now + delay, delay, task);
-    if(delay > IceUtil::Time() && token.scheduledTime < now)
-    {
-        throw IllegalArgumentException(__FILE__, __LINE__, "invalid delay");
-    }
-
-    bool inserted = _tasks.insert(make_pair(task, token.scheduledTime)).second;
-    if(!inserted)
-    {
-        throw IllegalArgumentException(__FILE__, __LINE__, "task is already scheduled");
-    }
-    _tokens.insert(token);
-
-    if(_wakeUpTime == IceUtil::Time() || token.scheduledTime < _wakeUpTime)
-    {
-        _monitor.notify();
-    }
+    lock_guard lock(_mutex);
+    return cancelNoSync(task);
 }
 
 bool
-Timer::cancel(const TimerTaskPtr& task)
+Timer::isScheduled(const TimerTaskPtr& task)
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
-    if(_destroyed)
-    {
-        return false;
-    }
-
-    map<TimerTaskPtr, IceUtil::Time, TimerTaskCompare>::iterator p = _tasks.find(task);
-    if(p == _tasks.end())
+    lock_guard lock(_mutex);
+    if (_destroyed)
     {
         return false;
     }
-
-    _tokens.erase(Token(p->second, IceUtil::Time(), p->first));
-    _tasks.erase(p);
-
-    return true;
+    return _tasks.find(task) != _tasks.end();
 }
 
 void
 Timer::run()
 {
-    Token token(IceUtil::Time(), IceUtil::Time(), 0);
-    while(true)
+    Token token{chrono::steady_clock::time_point(), nullopt, nullptr};
+    while (true)
     {
         {
-            IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
+            unique_lock lock(_mutex);
 
-            if(!_destroyed)
+            if (!_destroyed)
             {
-                //
-                // If the task we just ran is a repeated task, schedule it
-                // again for executation if it wasn't canceled.
-                //
-                if(token.delay != IceUtil::Time())
+                // If the task we just ran is a repeated task, schedule it again for execution if it wasn't canceled.
+                if (token.delay)
                 {
-                    map<TimerTaskPtr, IceUtil::Time, TimerTaskCompare>::iterator p = _tasks.find(token.task);
-                    if(p != _tasks.end())
+                    auto p = _tasks.find(token.task);
+                    if (p != _tasks.end())
                     {
-                        token.scheduledTime = IceUtil::Time::now(IceUtil::Time::Monotonic) + token.delay;
+                        token.scheduledTime = chrono::steady_clock::now() + token.delay.value();
                         p->second = token.scheduledTime;
                         _tokens.insert(token);
                     }
                 }
-                token = Token(IceUtil::Time(), IceUtil::Time(), 0);
+                token = {chrono::steady_clock::time_point(), nullopt, nullptr};
 
-                if(_tokens.empty())
+                if (_tokens.empty())
                 {
-                    _wakeUpTime = IceUtil::Time();
-                    _monitor.wait();
+                    _wakeUpTime = chrono::steady_clock::time_point();
+                    _condition.wait(lock);
                 }
             }
 
-            if(_destroyed)
+            if (_destroyed)
             {
                 break;
             }
 
-            while(!_tokens.empty() && !_destroyed)
+            while (!_tokens.empty() && !_destroyed)
             {
-                const IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic);
+                const auto now = chrono::steady_clock::now();
                 const Token& first = *(_tokens.begin());
-                if(first.scheduledTime <= now)
+                if (first.scheduledTime <= now)
                 {
                     token = first;
                     _tokens.erase(_tokens.begin());
-                    if(token.delay == IceUtil::Time())
+                    if (!token.delay)
                     {
                         _tasks.erase(token.task);
                     }
@@ -192,70 +103,65 @@ Timer::run()
                 }
 
                 _wakeUpTime = first.scheduledTime;
-                try
-                {
-                    _monitor.timedWait(first.scheduledTime - now);
-                }
-                catch(const IceUtil::InvalidTimeoutException&)
-                {
-                    IceUtil::Time timeout = (first.scheduledTime - now) / 2;
-                    while(timeout > IceUtil::Time())
-                    {
-                        try
-                        {
-                            _monitor.timedWait(timeout);
-                            break;
-                        }
-                        catch(const IceUtil::InvalidTimeoutException&)
-                        {
-                            timeout = timeout / 2;
-                        }
-                    }
-                }
+                _condition.wait_for(lock, first.scheduledTime - now);
             }
 
-            if(_destroyed)
+            if (_destroyed)
             {
                 break;
             }
         }
 
-        if(token.task)
+        if (token.task)
         {
             try
             {
                 runTimerTask(token.task);
             }
-            catch(const IceUtil::Exception& e)
+            catch (const Ice::Exception& e)
             {
-                consoleErr << "IceUtil::Timer::run(): uncaught exception:\n" << e.what();
-#ifdef __GNUC__
-                consoleErr << "\n" << e.ice_stackTrace();
-#endif
-                consoleErr << endl;
+                consoleErr << "Ice::Timer::run(): uncaught exception:\n" << e << endl;
             }
-            catch(const std::exception& e)
+            catch (const std::exception& e)
             {
-                consoleErr << "IceUtil::Timer::run(): uncaught exception:\n" << e.what() << endl;
+                consoleErr << "Ice::Timer::run(): uncaught exception:\n" << e.what() << endl;
             }
-            catch(...)
+            catch (...)
             {
-                consoleErr << "IceUtil::Timer::run(): uncaught exception" << endl;
+                consoleErr << "Ice::Timer::run(): uncaught exception" << endl;
             }
 
-            if(token.delay == IceUtil::Time())
+            if (!token.delay)
             {
-                //
-                // If thisthe task is not a repeated task, clear the task reference now rather than
+                // If the task is not a repeated task, clear the task reference now rather than
                 // in the synchronization block above. Clearing the task reference might end up
                 // calling user code which could trigger a deadlock. See also issue #352.
-                //
-                token.task = ICE_NULLPTR;
+                token.task = nullptr;
             }
         }
     }
 }
 
+bool
+Timer::cancelNoSync(const TimerTaskPtr& task) noexcept
+{
+    if (_destroyed)
+    {
+        return false;
+    }
+
+    auto p = _tasks.find(task);
+    if (p == _tasks.end())
+    {
+        return false;
+    }
+
+    _tokens.erase(Token{p->second, nullopt, p->first});
+    _tasks.erase(p);
+
+    return true;
+}
+
 void
 Timer::runTimerTask(const TimerTaskPtr& task)
 {

data/dist/ice/cpp/src/Ice/Timer.h

@@ -0,0 +1,212 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_TIMER_H
+#define ICE_TIMER_H
+
+#include "Ice/Config.h"
+#include "Ice/TimerTask.h"
+
+#include <cassert>
+#include <chrono>
+#include <condition_variable>
+#include <functional>
+#include <map>
+#include <mutex>
+#include <optional>
+#include <set>
+#include <stdexcept>
+#include <thread>
+
+namespace IceInternal
+{
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+    // Adapts a function<void()> to a TimerTask.
+    class InlineTimerTask final : public TimerTask
+    {
+    public:
+        InlineTimerTask(std::function<void()> function) : _function(std::move(function)) {}
+
+        void runTimerTask() final { _function(); }
+
+    private:
+        std::function<void()> _function;
+    };
+
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#endif
+
+    // The timer class is used to schedule tasks for one-time execution or repeated execution. Tasks are executed by a
+    // dedicated timer thread sequentially.
+    class ICE_API Timer
+    {
+    public:
+        Timer();
+        virtual ~Timer() = default;
+
+        // Destroy the timer and join the timer execution thread. Must not be called from a timer task.
+        void destroy();
+
+        // Schedule a function-task for execution after a given delay.
+        template<class Rep, class Period>
+        void schedule(std::function<void()> function, const std::chrono::duration<Rep, Period>& delay)
+        {
+            schedule(std::make_shared<InlineTimerTask>(std::move(function)), delay);
+        }
+
+        // Schedule task for execution after a given delay.
+        template<class Rep, class Period>
+        void schedule(const TimerTaskPtr& task, const std::chrono::duration<Rep, Period>& delay)
+        {
+            std::lock_guard lock(_mutex);
+            if (_destroyed)
+            {
+                throw std::invalid_argument("timer destroyed");
+            }
+
+            if (delay < std::chrono::nanoseconds::zero())
+            {
+                throw std::invalid_argument("invalid negative delay");
+            }
+
+            auto now = std::chrono::steady_clock::now();
+            auto time = now + delay;
+            if (delay > std::chrono::nanoseconds::zero() && time < now)
+            {
+                throw std::invalid_argument("delay too large, resulting in overflow");
+            }
+
+            bool inserted = _tasks.insert(make_pair(task, time)).second;
+            if (!inserted)
+            {
+                throw std::invalid_argument("task is already scheduled");
+            }
+            _tokens.insert({time, std::nullopt, task});
+
+            if (_wakeUpTime == std::chrono::steady_clock::time_point() || time < _wakeUpTime)
+            {
+                _condition.notify_one();
+            }
+        }
+
+        // Reschedule a task for execution after a given delay. This function also succeeds if the task was not
+        // previously scheduled.
+        template<class Rep, class Period>
+        void reschedule(const TimerTaskPtr& task, const std::chrono::duration<Rep, Period>& delay)
+        {
+            std::lock_guard lock(_mutex);
+            if (_destroyed)
+            {
+                throw std::invalid_argument("timer destroyed");
+            }
+
+            if (delay < std::chrono::nanoseconds::zero())
+            {
+                throw std::invalid_argument("invalid negative delay");
+            }
+
+            auto now = std::chrono::steady_clock::now();
+            auto time = now + delay;
+            if (delay > std::chrono::nanoseconds::zero() && time < now)
+            {
+                throw std::invalid_argument("delay too large, resulting in overflow");
+            }
+
+            cancelNoSync(task);
+
+            _tasks.insert(make_pair(task, time));
+            _tokens.insert({time, std::nullopt, task});
+
+            if (_wakeUpTime == std::chrono::steady_clock::time_point() || time < _wakeUpTime)
+            {
+                _condition.notify_one();
+            }
+        }
+
+        // Schedule a task for repeated execution with the given delay between each execution.
+        template<class Rep, class Period>
+        void scheduleRepeated(const TimerTaskPtr& task, const std::chrono::duration<Rep, Period>& delay)
+        {
+            std::lock_guard lock(_mutex);
+            if (_destroyed)
+            {
+                throw std::invalid_argument("timer destroyed");
+            }
+
+            if (delay < std::chrono::nanoseconds::zero())
+            {
+                throw std::invalid_argument("invalid negative delay");
+            }
+
+            auto now = std::chrono::steady_clock::now();
+            auto time = now + delay;
+            if (delay > std::chrono::nanoseconds::zero() && time < now)
+            {
+                throw std::invalid_argument("delay too large, resulting in overflow");
+            }
+
+            bool inserted = _tasks.insert(make_pair(task, time)).second;
+            if (!inserted)
+            {
+                throw std::invalid_argument("task is already scheduled");
+            }
+            _tokens.insert({time, std::chrono::duration_cast<std::chrono::nanoseconds>(delay), task});
+
+            if (_wakeUpTime == std::chrono::steady_clock::time_point() || time < _wakeUpTime)
+            {
+                _condition.notify_one();
+            }
+        }
+
+        //
+        // Cancel a task. Returns true if the task has not yet run or if
+        // it's a task scheduled for repeated execution. Returns false if
+        // the task has already run, was already cancelled or was never
+        // scheduled.
+        //
+        bool cancel(const TimerTaskPtr&) noexcept;
+
+        // Checks if this timer task is scheduled.
+        bool isScheduled(const TimerTaskPtr&);
+
+    protected:
+        virtual void runTimerTask(const TimerTaskPtr&);
+
+    private:
+        struct Token
+        {
+            std::chrono::steady_clock::time_point scheduledTime;
+            std::optional<std::chrono::nanoseconds> delay;
+            TimerTaskPtr task;
+            bool operator<(const Token& other) const
+            {
+                if (scheduledTime < other.scheduledTime)
+                {
+                    return true;
+                }
+                else if (scheduledTime > other.scheduledTime)
+                {
+                    return false;
+                }
+                return task < other.task;
+            }
+        };
+
+        void run();
+        bool cancelNoSync(const TimerTaskPtr& task) noexcept;
+
+        std::mutex _mutex;
+        std::condition_variable _condition;
+        std::set<Token> _tokens;
+        std::map<TimerTaskPtr, std::chrono::steady_clock::time_point> _tasks;
+        bool _destroyed{false};
+        std::chrono::steady_clock::time_point _wakeUpTime;
+        std::thread _worker;
+    };
+}
+
+#endif

data/dist/ice/cpp/src/Ice/TraceLevels.cpp

@@ -1,38 +1,20 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/TraceLevels.h>
-#include <Ice/Properties.h>
+#include "TraceLevels.h"
+#include "Ice/Properties.h"
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-IceUtil::Shared* IceInternal::upCast(TraceLevels* p) { return p; }
-
-IceInternal::TraceLevels::TraceLevels(const PropertiesPtr& properties) :
-    network(0),
-    networkCat("Network"),
-    protocol(0),
-    protocolCat("Protocol"),
-    retry(0),
-    retryCat("Retry"),
-    location(0),
-    locationCat("Locator"),
-    slicing(0),
-    slicingCat("Slicing"),
-    gc(0),
-    gcCat("GC"),
-    threadPool(0),
-    threadPoolCat("ThreadPool")
+IceInternal::TraceLevels::TraceLevels(const PropertiesPtr& properties)
 {
     const string keyBase = "Ice.Trace.";
-    const_cast<int&>(network) = properties->getPropertyAsInt(keyBase + networkCat);
-    const_cast<int&>(protocol) = properties->getPropertyAsInt(keyBase + protocolCat);
-    const_cast<int&>(retry) = properties->getPropertyAsInt(keyBase + retryCat);
-    const_cast<int&>(location) = properties->getPropertyAsInt(keyBase + locationCat);
-    const_cast<int&>(slicing) = properties->getPropertyAsInt(keyBase + slicingCat);
-    const_cast<int&>(gc) = properties->getPropertyAsInt(keyBase + gcCat);
-    const_cast<int&>(threadPool) = properties->getPropertyAsInt(keyBase + threadPoolCat);
+    const_cast<int&>(dispatch) = properties->getIcePropertyAsInt(keyBase + dispatchCat);
+    const_cast<int&>(network) = properties->getIcePropertyAsInt(keyBase + networkCat);
+    const_cast<int&>(protocol) = properties->getIcePropertyAsInt(keyBase + protocolCat);
+    const_cast<int&>(retry) = properties->getIcePropertyAsInt(keyBase + retryCat);
+    const_cast<int&>(location) = properties->getIcePropertyAsInt(keyBase + locationCat);
+    const_cast<int&>(slicing) = properties->getIcePropertyAsInt(keyBase + slicingCat);
+    const_cast<int&>(threadPool) = properties->getIcePropertyAsInt(keyBase + threadPoolCat);
 }

data/dist/ice/cpp/src/Ice/TraceLevels.h

@@ -1,45 +1,39 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_TRACE_LEVELS_H
 #define ICE_TRACE_LEVELS_H
 
-#include <IceUtil/Shared.h>
-#include <Ice/TraceLevelsF.h>
-#include <Ice/PropertiesF.h>
+#include "Ice/PropertiesF.h"
+#include "TraceLevelsF.h"
 
 namespace IceInternal
 {
+    class TraceLevels
+    {
+    public:
+        TraceLevels(const Ice::PropertiesPtr&);
 
-class TraceLevels : public ::IceUtil::Shared
-{
-public:
-
-    TraceLevels(const ::Ice::PropertiesPtr&);
-
-    const int network;
-    const char* networkCat;
-
-    const int protocol;
-    const char* protocolCat;
+        const int dispatch{0};
+        const char* dispatchCat{"Dispatch"};
 
-    const int retry;
-    const char* retryCat;
+        const int network{0};
+        const char* networkCat{"Network"};
 
-    const int location;
-    const char* locationCat;
+        const int protocol{0};
+        const char* protocolCat{"Protocol"};
 
-    const int slicing;
-    const char* slicingCat;
+        const int retry{0};
+        const char* retryCat{"Retry"};
 
-    const int gc;
-    const char* gcCat;
+        const int location{0};
+        const char* locationCat{"Locator"};
 
-    const int threadPool;
-    const char* threadPoolCat;
-};
+        const int slicing{0};
+        const char* slicingCat{"Slicing"};
 
+        const int threadPool{0};
+        const char* threadPoolCat{"ThreadPool"};
+    };
 }
 
 #endif

data/dist/ice/cpp/src/Ice/TraceLevelsF.h

@@ -1,21 +1,14 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_TRACE_LEVELS_F_H
 #define ICE_TRACE_LEVELS_F_H
 
-#include <IceUtil/Shared.h>
-
-#include <Ice/Handle.h>
+#include <memory>
 
 namespace IceInternal
 {
-
-class TraceLevels;
-IceUtil::Shared* upCast(TraceLevels*);
-typedef Handle<TraceLevels> TraceLevelsPtr;
-
+    class TraceLevels;
+    using TraceLevelsPtr = std::shared_ptr<TraceLevels>;
 }
 
 #endif