zeroc-ice 3.7.9.1 → 3.8.0

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

@@ -0,0 +1,305 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_THREAD_POOL_H
+#define ICE_THREAD_POOL_H
+
+#include "EventHandler.h"
+#include "Ice/Config.h"
+#include "Ice/InputStream.h"
+#include "Ice/InstanceF.h"
+#include "Ice/Logger.h"
+#include "Ice/ObserverHelper.h"
+#include "Ice/PropertiesF.h"
+#include "Selector.h"
+#include "ThreadPoolF.h"
+
+#include <list>
+#include <set>
+#include <thread>
+
+namespace IceInternal
+{
+    class ThreadPoolCurrent;
+
+    class ThreadPoolWorkQueue;
+    using ThreadPoolWorkQueuePtr = std::shared_ptr<ThreadPoolWorkQueue>;
+
+    class ThreadPool : public std::enable_shared_from_this<ThreadPool>
+    {
+    public:
+        class EventHandlerThread final : public std::enable_shared_from_this<EventHandlerThread>
+        {
+        public:
+            EventHandlerThread(ThreadPoolPtr, std::string);
+            void start();
+            void run();
+            void join();
+
+            void updateObserver();
+            void setState(Ice::Instrumentation::ThreadState);
+
+        private:
+            std::string _name;
+            ThreadPoolPtr _pool;
+            ObserverHelperT<Ice::Instrumentation::ThreadObserver> _observer;
+            Ice::Instrumentation::ThreadState _state{Ice::Instrumentation::ThreadState::ThreadStateIdle};
+            std::thread _thread;
+        };
+        using EventHandlerThreadPtr = std::shared_ptr<EventHandlerThread>;
+
+        static ThreadPoolPtr create(const InstancePtr&, const std::string&, int);
+
+        virtual ~ThreadPool();
+
+        void destroy();
+
+        void updateObservers();
+
+        void initialize(const EventHandlerPtr&);
+        void _register(const EventHandlerPtr& handler, SocketOperation status)
+        {
+            update(handler, SocketOperationNone, status);
+        }
+        void update(const EventHandlerPtr&, SocketOperation, SocketOperation);
+        void unregister(const EventHandlerPtr& handler, SocketOperation status)
+        {
+            update(handler, status, SocketOperationNone);
+        }
+        bool finish(const EventHandlerPtr&, bool);
+        void ready(const EventHandlerPtr&, SocketOperation, bool);
+
+        void executeFromThisThread(std::function<void()>, const Ice::ConnectionPtr&);
+        void execute(std::function<void()>, const Ice::ConnectionPtr&);
+
+        void joinWithAllThreads();
+
+        [[nodiscard]] std::string prefix() const;
+
+    private:
+        ThreadPool(const InstancePtr&, std::string, int);
+        void initialize();
+
+        void run(const EventHandlerThreadPtr&);
+
+        bool ioCompleted(ThreadPoolCurrent&);
+
+#if defined(ICE_USE_IOCP)
+        bool startMessage(ThreadPoolCurrent&);
+        void finishMessage(ThreadPoolCurrent&);
+#else
+        void promoteFollower(ThreadPoolCurrent&);
+        bool followerWait(ThreadPoolCurrent&, std::unique_lock<std::mutex>&);
+#endif
+
+        std::string nextThreadId();
+
+        static void joinThread(const EventHandlerThreadPtr&);
+        static void shutdown(const ThreadPoolCurrent&, const InstancePtr&);
+
+        const InstancePtr _instance;
+
+        std::function<void(std::function<void()>, const Ice::ConnectionPtr&)> _executor;
+
+        ThreadPoolWorkQueuePtr _workQueue;
+        bool _destroyed{false};
+        const std::string _prefix;
+        Selector _selector;
+        int _nextThreadId{0};
+
+        friend class EventHandlerThread;
+        friend class ThreadPoolCurrent;
+        friend class ThreadPoolWorkQueue;
+
+        const int _size{0};     // Number of threads that are pre-created.
+        const int _sizeIO{0};   // Maximum number of threads that can concurrently perform IO.
+        const int _sizeMax{0};  // Maximum number of threads.
+        const int _sizeWarn{0}; // If _inUse reaches _sizeWarn, a "low on threads" warning will be printed.
+        const bool _serialize;  // True if requests need to be serialized over the connection.
+        const int _serverIdleTime;
+        const int _threadIdleTime{0};
+
+        std::set<EventHandlerThreadPtr> _threads; // All threads, running or not.
+        int _inUse{0};                            // Number of threads that are currently in use.
+#if !defined(ICE_USE_IOCP)
+        int _inUseIO{0}; // Number of threads that are currently performing IO.
+        std::vector<std::pair<EventHandler*, SocketOperation>> _handlers;
+        std::vector<std::pair<EventHandler*, SocketOperation>>::const_iterator _nextHandler;
+#endif
+
+        bool _promote{true};
+        std::mutex _mutex;
+        std::condition_variable _conditionVariable;
+    };
+
+    class ThreadPoolCurrent
+    {
+    public:
+        ThreadPoolCurrent(const ThreadPoolPtr&, ThreadPool::EventHandlerThreadPtr);
+
+        SocketOperation operation{SocketOperationNone};
+
+        bool ioCompleted() const // NOLINT(modernize-use-nodiscard)
+        {
+            return _threadPool->ioCompleted(const_cast<ThreadPoolCurrent&>(*this));
+        }
+
+#if defined(ICE_USE_IOCP)
+        bool startMessage() { return _threadPool->startMessage(const_cast<ThreadPoolCurrent&>(*this)); }
+
+        void finishMessage() { _threadPool->finishMessage(const_cast<ThreadPoolCurrent&>(*this)); }
+#else
+        bool ioReady() { return (_handler->_registered & operation) != 0; }
+#endif
+
+    private:
+        ThreadPool* _threadPool;
+        ThreadPool::EventHandlerThreadPtr _thread;
+        EventHandlerPtr _handler;
+        bool _ioCompleted{false};
+#if !defined(ICE_USE_IOCP)
+        bool _leader{false};
+#else
+        DWORD _count;
+        int _error;
+#endif
+        friend class ThreadPool;
+    };
+
+    class ThreadPoolWorkQueue : public EventHandler
+    {
+    public:
+        ThreadPoolWorkQueue(ThreadPool&);
+
+        void destroy();
+        void queue(std::function<void(ThreadPoolCurrent&)>);
+
+#if defined(ICE_USE_IOCP)
+        bool startAsync(SocketOperation);
+        bool finishAsync(SocketOperation);
+#endif
+
+        void message(ThreadPoolCurrent&) override;
+        void finished(ThreadPoolCurrent&, bool) override;
+        [[nodiscard]] std::string toString() const override;
+        NativeInfoPtr getNativeInfo() override;
+
+    private:
+        ThreadPool& _threadPool;
+        bool _destroyed{false};
+        std::list<std::function<void(ThreadPoolCurrent&)>> _workItems;
+    };
+
+//
+// The ThreadPoolMessage class below hides the IOCP implementation details from
+// the event handler implementations. Only event handler implementation that
+// require IO need to use this class.
+//
+// An instance of the IOScope subclass must be created within the synchronization
+// of the event handler. It takes care of calling startMessage/finishMessage for
+// the IOCP implementation and ensures that finishMessage isn't called multiple
+// times.
+//
+#if !defined(ICE_USE_IOCP)
+    template<class T> class ThreadPoolMessage
+    {
+    public:
+        class IOScope
+        {
+        public:
+            IOScope(ThreadPoolMessage<T>& message) : _message(message) {}
+
+            operator bool()
+            {
+                return _message._current.ioReady(); // Ensure the handler is still interested in the operation.
+            }
+
+            void completed() { _message._current.ioCompleted(); }
+
+        private:
+            ThreadPoolMessage<T>& _message;
+        };
+        friend class IOScope;
+
+        ThreadPoolMessage(ThreadPoolCurrent& current, const T&) : _current(current) {}
+
+    private:
+        ThreadPoolCurrent& _current;
+    };
+
+#else
+
+    template<class T> class ThreadPoolMessage
+    {
+    public:
+        class IOScope
+        {
+        public:
+            IOScope(ThreadPoolMessage& message) : _message(message)
+            {
+                // This must be called with the handler locked.
+                _finish = _message._current.startMessage();
+            }
+
+            ~IOScope()
+            {
+                if (_finish)
+                {
+                    // This must be called with the handler locked.
+                    _message._current.finishMessage();
+                }
+            }
+
+            operator bool() { return _finish; }
+
+            void completed()
+            {
+                //
+                // Call finishMessage once IO is completed only if serialization is not enabled.
+                // Otherwise, finishMessage will be called when the event handler is done with
+                // the message (it will be called from ~ThreadPoolMessage below).
+                //
+                assert(_finish);
+                if (_message._current.ioCompleted())
+                {
+                    _finish = false;
+                    _message._finish = true;
+                }
+            }
+
+        private:
+            ThreadPoolMessage& _message;
+            bool _finish;
+        };
+        friend class IOScope;
+
+        ThreadPoolMessage(ThreadPoolCurrent& current, const T& eventHandler)
+            : _current(current),
+              _eventHandler(eventHandler),
+              _finish(false)
+        {
+        }
+
+        ~ThreadPoolMessage()
+        {
+            if (_finish)
+            {
+                //
+                // A ThreadPoolMessage instance must be created outside the synchronization
+                // of the event handler. We need to lock the event handler here to call
+                // finishMessage.
+                //
+                std::lock_guard lock(_eventHandler._mutex);
+                _current.finishMessage();
+            }
+        }
+
+    private:
+        ThreadPoolCurrent& _current;
+        const T& _eventHandler;
+        bool _finish;
+    };
+#endif
+
+};
+
+#endif

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

@@ -0,0 +1,14 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_THREAD_POOL_F_H
+#define ICE_THREAD_POOL_F_H
+
+#include <memory>
+
+namespace IceInternal
+{
+    class ThreadPool;
+    using ThreadPoolPtr = std::shared_ptr<ThreadPool>;
+}
+
+#endif

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

@@ -0,0 +1,47 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "TimeUtil.h"
+
+#include <sstream>
+
+using namespace IceInternal;
+using namespace std;
+
+string
+IceInternal::timePointToString(const chrono::system_clock::time_point& timePoint, const string& format)
+{
+    time_t time = static_cast<time_t>(chrono::duration_cast<chrono::seconds>(timePoint.time_since_epoch()).count());
+    struct tm tr;
+#ifdef _MSC_VER
+    // localtime_s in Microsoft CRT is incompatible with the C standard as it returns errno_t instead of struct tm*
+    errno_t p = localtime_s(&tr, &time);
+    if (p)
+    {
+        return std::string{};
+    }
+#else
+    // the standard localtime_r returns a null pointer on error.
+    struct tm* p = localtime_r(&time, &tr);
+    if (!p)
+    {
+        return std::string{};
+    }
+#endif
+
+    char buf[32];
+    return strftime(buf, sizeof(buf), format.c_str(), &tr) == 0 ? std::string{} : std::string{buf};
+}
+
+string
+IceInternal::timePointToDateTimeString(const chrono::system_clock::time_point& timePoint)
+{
+    const string format = "%x %H:%M:%S";
+    ostringstream os;
+    os << timePointToString(timePoint, format);
+    os << '.';
+    os.fill('0');
+    os.width(3);
+    auto usec = chrono::duration_cast<chrono::microseconds>(timePoint.time_since_epoch());
+    os << static_cast<std::int64_t>(usec.count() % 1000000 / 1000);
+    return os.str();
+}

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

@@ -0,0 +1,21 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_TIME_UTIL_H
+#define ICE_TIME_UTIL_H
+
+#include "Ice/Config.h"
+
+#include <chrono>
+#include <string>
+
+namespace IceInternal
+{
+    // Convert a time point to a string using the specified format. The format string is a format string for strftime.
+    ICE_API std::string timePointToString(const std::chrono::system_clock::time_point& time, const std::string& format);
+
+    // Convert a time point to a string using the format "%x %H:%M:%S". The number of milliseconds is appended to the
+    // string.
+    ICE_API std::string timePointToDateTimeString(const std::chrono::system_clock::time_point& time);
+}
+
+#endif

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

@@ -0,0 +1,169 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Timer.h"
+#include "ConsoleUtil.h"
+#include "Ice/Exception.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+TimerTask::~TimerTask() = default; // Out of line to avoid weak vtable
+
+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");
+    }
+    {
+        std::lock_guard lock(_mutex);
+        if (_destroyed)
+        {
+            return;
+        }
+        _destroyed = true;
+        _tasks.clear();
+        _tokens.clear();
+        _condition.notify_one();
+    }
+    _worker.join();
+}
+
+bool
+Timer::cancel(const TimerTaskPtr& task) noexcept
+{
+    lock_guard lock(_mutex);
+    return cancelNoSync(task);
+}
+
+bool
+Timer::isScheduled(const TimerTaskPtr& task)
+{
+    lock_guard lock(_mutex);
+    if (_destroyed)
+    {
+        return false;
+    }
+    return _tasks.find(task) != _tasks.end();
+}
+
+void
+Timer::run()
+{
+    Token token{chrono::steady_clock::time_point(), nullopt, nullptr};
+    while (true)
+    {
+        {
+            unique_lock lock(_mutex);
+
+            if (!_destroyed)
+            {
+                // If the task we just ran is a repeated task, schedule it again for execution if it wasn't canceled.
+                if (token.delay)
+                {
+                    auto p = _tasks.find(token.task);
+                    if (p != _tasks.end())
+                    {
+                        token.scheduledTime = chrono::steady_clock::now() + token.delay.value();
+                        p->second = token.scheduledTime;
+                        _tokens.insert(token);
+                    }
+                }
+                token = {chrono::steady_clock::time_point(), nullopt, nullptr};
+
+                if (_tokens.empty())
+                {
+                    _wakeUpTime = chrono::steady_clock::time_point();
+                    _condition.wait(lock);
+                }
+            }
+
+            if (_destroyed)
+            {
+                break;
+            }
+
+            while (!_tokens.empty() && !_destroyed)
+            {
+                const auto now = chrono::steady_clock::now();
+                const Token& first = *(_tokens.begin());
+                if (first.scheduledTime <= now)
+                {
+                    token = first;
+                    _tokens.erase(_tokens.begin());
+                    if (!token.delay)
+                    {
+                        _tasks.erase(token.task);
+                    }
+                    break;
+                }
+
+                _wakeUpTime = first.scheduledTime;
+                _condition.wait_for(lock, first.scheduledTime - now);
+            }
+
+            if (_destroyed)
+            {
+                break;
+            }
+        }
+
+        if (token.task)
+        {
+            try
+            {
+                runTimerTask(token.task);
+            }
+            catch (const Ice::Exception& e)
+            {
+                consoleErr << "Ice::Timer::run(): uncaught exception:\n" << e << endl;
+            }
+            catch (const std::exception& e)
+            {
+                consoleErr << "Ice::Timer::run(): uncaught exception:\n" << e.what() << endl;
+            }
+            catch (...)
+            {
+                consoleErr << "Ice::Timer::run(): uncaught exception" << endl;
+            }
+
+            if (!token.delay)
+            {
+                // 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 = 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)
+{
+    task->runTimerTask();
+}