heartbeat.hpp

Go to the documentation of this file.

//===- lib/core/heartbeat.hpp -----------------------------*- mode: C++ -*-===//
//*  _                     _   _                _    *
//* | |__   ___  __ _ _ __| |_| |__   ___  __ _| |_  *
//* | '_ \ / _ \/ _` | '__| __| '_ \ / _ \/ _` | __| *
//* | | | |  __/ (_| | |  | |_| |_) |  __/ (_| | |_  *
//* |_| |_|\___|\__,_|_|   \__|_.__/ \___|\__,_|\__| *
//*                                                  *
//===----------------------------------------------------------------------===//
//
// Part of the pstore project, under the Apache License v2.0 with LLVM Exceptions.
// See https://github.com/SNSystems/pstore/blob/master/LICENSE.txt for license
// information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef PSTORE_CORE_HEARTBEAT_HPP
#define PSTORE_CORE_HEARTBEAT_HPP

#include <atomic>
#include <chrono>
#include <condition_variable>
#include <functional>
#include <memory>
#include <mutex>
#include <thread>
#include <unordered_map>

namespace pstore {

    class heartbeat {
    public:
        static std::shared_ptr<heartbeat> get ();

        ~heartbeat ();

        heartbeat (heartbeat const &) = delete;
        heartbeat & operator= (heartbeat const &) = delete;

        using key_type = std::uintptr_t;

        template <typename T>
        static key_type to_key_type (T * t) {
            static_assert (sizeof (key_type) <= sizeof (t), "heartbeat::key_type is too small");
            return reinterpret_cast<key_type> (t);
        }

        using callback = std::function<void (key_type)>;
        void attach (key_type key, callback cb);
        void detach (key_type key);

        void stop ();

        class worker_thread {
        public:
            worker_thread ();
            worker_thread (worker_thread const &) = delete;
            worker_thread (worker_thread &&) = delete;

            ~worker_thread () = default;

            worker_thread & operator= (worker_thread const &) = delete;
            worker_thread & operator= (worker_thread &&) = delete;

            void attach (heartbeat::key_type key, callback cb);
            void detach (heartbeat::key_type key);

            void run () noexcept;

            void step () const;

            void stop () noexcept;

        private:
            using duration_type = std::chrono::milliseconds;
            static duration_type const delay_time_;
            static duration_type const max_time_;

            duration_type const * sleep_time_;

            bool done_ = false;

            std::mutex mut_;
            std::condition_variable cv_;

            std::unordered_map<heartbeat::key_type, heartbeat::callback> callbacks_;
        };

    private:
        heartbeat () noexcept = default;

        struct state {
            worker_thread worker;
            std::thread thread;
        };
        std::unique_ptr<state> state_;
    };

} // end namespace pstore

#endif // PSTORE_CORE_HEARTBEAT_HPP