zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,253 +1,193 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_THREAD_POOL_H
 #define ICE_THREAD_POOL_H
 
-#include <IceUtil/Shared.h>
-#include <IceUtil/Mutex.h>
-#include <IceUtil/Monitor.h>
-#include <IceUtil/Thread.h>
-
-#include <Ice/Config.h>
-#include <Ice/Dispatcher.h>
-#include <Ice/ThreadPoolF.h>
-#include <Ice/InstanceF.h>
-#include <Ice/LoggerF.h>
-#include <Ice/PropertiesF.h>
-#include <Ice/EventHandler.h>
-#include <Ice/Selector.h>
-#include <Ice/InputStream.h>
-#include <Ice/ObserverHelper.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 <set>
 #include <list>
+#include <set>
+#include <thread>
 
 namespace IceInternal
 {
+    class ThreadPoolCurrent;
 
-class ThreadPoolCurrent;
-
-class ThreadPoolWorkQueue;
-ICE_DEFINE_PTR(ThreadPoolWorkQueuePtr, ThreadPoolWorkQueue);
-
-class ThreadPoolWorkItem : public virtual IceUtil::Shared
-{
-public:
-
-    virtual void execute(ThreadPoolCurrent&) = 0;
-};
-typedef IceUtil::Handle<ThreadPoolWorkItem> ThreadPoolWorkItemPtr;
-
-class DispatchWorkItem : public ThreadPoolWorkItem, public Ice::DispatcherCall
-{
-public:
+    class ThreadPoolWorkQueue;
+    using ThreadPoolWorkQueuePtr = std::shared_ptr<ThreadPoolWorkQueue>;
 
-    DispatchWorkItem();
-    DispatchWorkItem(const Ice::ConnectionPtr& connection);
-
-    const Ice::ConnectionPtr&
-    getConnection()
+    class ThreadPool : public std::enable_shared_from_this<ThreadPool>
     {
-        return _connection;
-    }
+    public:
+        class EventHandlerThread final : public std::enable_shared_from_this<EventHandlerThread>
+        {
+        public:
+            EventHandlerThread(ThreadPoolPtr, std::string);
+            void start();
+            void run();
+            void join();
 
-private:
+            void updateObserver();
+            void setState(Ice::Instrumentation::ThreadState);
 
-    virtual void execute(ThreadPoolCurrent&);
+        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>;
 
-    const Ice::ConnectionPtr _connection;
-};
-typedef IceUtil::Handle<DispatchWorkItem> DispatchWorkItemPtr;
+        static ThreadPoolPtr create(const InstancePtr&, const std::string&, int);
 
-class ThreadPool : public IceUtil::Shared, private IceUtil::Monitor<IceUtil::Mutex>
-{
-    class EventHandlerThread : public IceUtil::Thread
-    {
-    public:
+        virtual ~ThreadPool();
 
-        EventHandlerThread(const ThreadPoolPtr&, const std::string&);
-        virtual void run();
+        void destroy();
 
-        void updateObserver();
-        void setState(Ice::Instrumentation::ThreadState);
+        void updateObservers();
 
-    private:
+        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);
 
-        ThreadPoolPtr _pool;
-        ObserverHelperT<Ice::Instrumentation::ThreadObserver> _observer;
-        Ice::Instrumentation::ThreadState _state;
-    };
-    typedef IceUtil::Handle<EventHandlerThread> EventHandlerThreadPtr;
+        void executeFromThisThread(std::function<void()>, const Ice::ConnectionPtr&);
+        void execute(std::function<void()>, const Ice::ConnectionPtr&);
 
-public:
+        void joinWithAllThreads();
 
-    ThreadPool(const InstancePtr&, const std::string&, int);
-    virtual ~ThreadPool();
+        [[nodiscard]] std::string prefix() const;
 
-    void destroy();
+    private:
+        ThreadPool(const InstancePtr&, std::string, int);
+        void initialize();
 
-    void updateObservers();
+        void run(const EventHandlerThreadPtr&);
 
-    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);
+        bool ioCompleted(ThreadPoolCurrent&);
 
-    void dispatchFromThisThread(const DispatchWorkItemPtr&);
-    void dispatch(const DispatchWorkItemPtr&);
+#if defined(ICE_USE_IOCP)
+        bool startMessage(ThreadPoolCurrent&);
+        void finishMessage(ThreadPoolCurrent&);
+#else
+        void promoteFollower(ThreadPoolCurrent&);
+        bool followerWait(ThreadPoolCurrent&, std::unique_lock<std::mutex>&);
+#endif
 
-    void joinWithAllThreads();
+        std::string nextThreadId();
 
-    std::string prefix() const;
+        static void joinThread(const EventHandlerThreadPtr&);
+        static void shutdown(const ThreadPoolCurrent&, const InstancePtr&);
 
-#ifdef ICE_SWIFT
-    dispatch_queue_t getDispatchQueue() const ICE_NOEXCEPT;
-#endif
+        const InstancePtr _instance;
 
-private:
+        std::function<void(std::function<void()>, const Ice::ConnectionPtr&)> _executor;
 
-    void run(const EventHandlerThreadPtr&);
+        ThreadPoolWorkQueuePtr _workQueue;
+        bool _destroyed{false};
+        const std::string _prefix;
+        Selector _selector;
+        int _nextThreadId{0};
 
-    bool ioCompleted(ThreadPoolCurrent&);
+        friend class EventHandlerThread;
+        friend class ThreadPoolCurrent;
+        friend class ThreadPoolWorkQueue;
 
-#if defined(ICE_USE_IOCP)
-    bool startMessage(ThreadPoolCurrent&);
-    void finishMessage(ThreadPoolCurrent&);
-#else
-    void promoteFollower(ThreadPoolCurrent&);
-    bool followerWait(ThreadPoolCurrent&);
-#endif
+        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::string nextThreadId();
-
-    const InstancePtr _instance;
-#ifdef ICE_SWIFT
-    const dispatch_queue_t _dispatchQueue;
-#else // Ice for Swift does not support a dispatcher
-#   ifdef ICE_CPP11_MAPPING
-    std::function<void(std::function<void()>, const std::shared_ptr<Ice::Connection>&)> _dispatcher;
-#   else
-    const Ice::DispatcherPtr _dispatcher;
-#   endif
-#endif
-    ThreadPoolWorkQueuePtr _workQueue;
-    bool _destroyed;
-    const std::string _prefix;
-    Selector _selector;
-    int _nextThreadId;
-
-    friend class EventHandlerThread;
-    friend class ThreadPoolCurrent;
-    friend class ThreadPoolWorkQueue;
-
-    const int _size; // Number of threads that are pre-created.
-    const int _sizeIO; // Maximum number of threads that can concurrently perform IO.
-    const int _sizeMax; // Maximum number of threads.
-    const int _sizeWarn; // 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 bool _hasPriority;
-    const int _priority;
-    const int _serverIdleTime;
-    const int _threadIdleTime;
-    const size_t _stackSize;
-
-    std::set<EventHandlerThreadPtr> _threads; // All threads, running or not.
-    int _inUse; // Number of threads that are currently in use.
+        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; // Number of threads that are currently performing IO.
-    std::vector<std::pair<EventHandler*, SocketOperation> > _handlers;
-    std::vector<std::pair<EventHandler*, SocketOperation> >::const_iterator _nextHandler;
+        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;
-};
-
-class ThreadPoolCurrent
-{
-public:
+        bool _promote{true};
+        std::mutex _mutex;
+        std::condition_variable _conditionVariable;
+    };
 
-    ThreadPoolCurrent(const InstancePtr&, const ThreadPoolPtr&, const ThreadPool::EventHandlerThreadPtr&);
+    class ThreadPoolCurrent
+    {
+    public:
+        ThreadPoolCurrent(const ThreadPoolPtr&, ThreadPool::EventHandlerThreadPtr);
 
-    SocketOperation operation;
-    Ice::InputStream stream; // A per-thread stream to be used by event handlers for optimization.
+        SocketOperation operation{SocketOperationNone};
 
-    bool ioCompleted() const
-    {
-        return _threadPool->ioCompleted(const_cast<ThreadPoolCurrent&>(*this));
-    }
+        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));
-    }
+        bool startMessage() { return _threadPool->startMessage(const_cast<ThreadPoolCurrent&>(*this)); }
 
-    void finishMessage()
-    {
-        _threadPool->finishMessage(const_cast<ThreadPoolCurrent&>(*this));
-    }
+        void finishMessage() { _threadPool->finishMessage(const_cast<ThreadPoolCurrent&>(*this)); }
 #else
-    bool ioReady()
-    {
-        return (_handler->_registered & operation) != 0;
-    }
+        bool ioReady() { return (_handler->_registered & operation) != 0; }
 #endif
 
-    void dispatchFromThisThread(const DispatchWorkItemPtr& workItem)
-    {
-        _threadPool->dispatchFromThisThread(workItem);
-    }
-
-private:
-
-    ThreadPool* _threadPool;
-    ThreadPool::EventHandlerThreadPtr _thread;
-    EventHandlerPtr _handler;
-    bool _ioCompleted;
+    private:
+        ThreadPool* _threadPool;
+        ThreadPool::EventHandlerThreadPtr _thread;
+        EventHandlerPtr _handler;
+        bool _ioCompleted{false};
 #if !defined(ICE_USE_IOCP)
-    bool _leader;
+        bool _leader{false};
 #else
-    DWORD _count;
-    int _error;
+        DWORD _count;
+        int _error;
 #endif
-    friend class ThreadPool;
-};
-
-class ThreadPoolWorkQueue : public EventHandler
-{
-public:
+        friend class ThreadPool;
+    };
 
-    ThreadPoolWorkQueue(ThreadPool&);
+    class ThreadPoolWorkQueue : public EventHandler
+    {
+    public:
+        ThreadPoolWorkQueue(ThreadPool&);
 
-    void destroy();
-    void queue(const ThreadPoolWorkItemPtr&);
+        void destroy();
+        void queue(std::function<void(ThreadPoolCurrent&)>);
 
 #if defined(ICE_USE_IOCP)
-    bool startAsync(SocketOperation);
-    bool finishAsync(SocketOperation);
+        bool startAsync(SocketOperation);
+        bool finishAsync(SocketOperation);
 #endif
 
-    virtual void message(ThreadPoolCurrent&);
-    virtual void finished(ThreadPoolCurrent&, bool);
-    virtual std::string toString() const;
-    virtual NativeInfoPtr getNativeInfo();
-
-private:
+        void message(ThreadPoolCurrent&) override;
+        void finished(ThreadPoolCurrent&, bool) override;
+        [[nodiscard]] std::string toString() const override;
+        NativeInfoPtr getNativeInfo() override;
 
-    ThreadPool& _threadPool;
-    bool _destroyed;
-    std::list<ThreadPoolWorkItemPtr> _workItems;
-};
+    private:
+        ThreadPool& _threadPool;
+        bool _destroyed{false};
+        std::list<std::function<void(ThreadPoolCurrent&)>> _workItems;
+    };
 
 //
 // The ThreadPoolMessage class below hides the IOCP implementation details from
@@ -260,132 +200,104 @@ private:
 // times.
 //
 #if !defined(ICE_USE_IOCP)
-template<class T> class ThreadPoolMessage
-{
-public:
-
-    class IOScope
+    template<class T> class ThreadPoolMessage
     {
     public:
-
-        IOScope(ThreadPoolMessage<T>& message) : _message(message)
+        class IOScope
         {
-            // Nothing to do.
-        }
+        public:
+            IOScope(ThreadPoolMessage<T>& message) : _message(message) {}
 
-        ~IOScope()
-        {
-            // Nothing to do.
-        }
+            operator bool()
+            {
+                return _message._current.ioReady(); // Ensure the handler is still interested in the operation.
+            }
 
-        operator bool()
-        {
-            return _message._current.ioReady(); // Ensure the handler is still interested in the operation.
-        }
+            void completed() { _message._current.ioCompleted(); }
 
-        void completed()
-        {
-            _message._current.ioCompleted();
-        }
+        private:
+            ThreadPoolMessage<T>& _message;
+        };
+        friend class IOScope;
 
-    private:
+        ThreadPoolMessage(ThreadPoolCurrent& current, const T&) : _current(current) {}
 
-        ThreadPoolMessage<T>& _message;
+    private:
+        ThreadPoolCurrent& _current;
     };
-    friend class IOScope;
-
-    ThreadPoolMessage(ThreadPoolCurrent& current, const T&) : _current(current)
-    {
-    }
-
-    ~ThreadPoolMessage()
-    {
-        // Nothing to do.
-    }
-
-private:
-
-    ThreadPoolCurrent& _current;
-};
 
 #else
 
-template<class T> class ThreadPoolMessage
-{
-public:
-
-    class IOScope
+    template<class T> class ThreadPoolMessage
     {
     public:
-
-        IOScope(ThreadPoolMessage& message) : _message(message)
-        {
-            // This must be called with the handler locked.
-            _finish = _message._current.startMessage();
-        }
-
-        ~IOScope()
+        class IOScope
         {
-            if(_finish)
+        public:
+            IOScope(ThreadPoolMessage& message) : _message(message)
             {
                 // This must be called with the handler locked.
-                _message._current.finishMessage();
+                _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;
+                }
             }
-        }
 
-        operator bool()
+        private:
+            ThreadPoolMessage& _message;
+            bool _finish;
+        };
+        friend class IOScope;
+
+        ThreadPoolMessage(ThreadPoolCurrent& current, const T& eventHandler)
+            : _current(current),
+              _eventHandler(eventHandler),
+              _finish(false)
         {
-            return _finish;
         }
 
-        void
-        completed()
+        ~ThreadPoolMessage()
         {
-            //
-            // 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())
+            if (_finish)
             {
-                _finish = false;
-                _message._finish = true;
+                //
+                // 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:
-
-        ThreadPoolMessage& _message;
+        ThreadPoolCurrent& _current;
+        const T& _eventHandler;
         bool _finish;
     };
-    friend class IOScope;
-
-    ThreadPoolMessage(ThreadPoolCurrent& current, const T& mutex) :
-        _current(current), _mutex(mutex), _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.
-            //
-            IceUtil::LockT<T> sync(_mutex);
-            _current.finishMessage();
-        }
-    }
-
-private:
-
-    ThreadPoolCurrent& _current;
-    const T& _mutex;
-    bool _finish;
-};
 #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