perf.h

Go to the documentation of this file.

#ifndef FPMAS_PERF_H
#define FPMAS_PERF_H
 
#include <unordered_map>
#include <functional>
#include "fpmas/api/utils/perf.h"
#include "nlohmann/json.hpp"
#include "fpmas/io/csv_output.h"
#include "fpmas/api/model/model.h"
 
namespace fpmas { namespace utils { namespace perf {
    using api::utils::perf::Clock;
    using api::utils::perf::ClockTime;
    using api::utils::perf::Duration;
 
    class Probe : public api::utils::perf::Probe {
        private:
            std::string _label;
            std::vector<Duration> _durations;
            ClockTime start_time;
            std::function<bool()> condition {[] {return true;}};
            bool running = false;
 
        public:
            Probe(std::string label) : _label(label) {}
            Probe(std::string label, std::function<bool()> condition) :
                _label(label), condition(condition) {}
 
            std::string label() const override {
                return _label;
            }
 
            std::vector<Duration>& durations() override {
                return _durations;
            }
            const std::vector<Duration>& durations() const override {
                return _durations;
            }
 
            void start() override;
            void stop() override;
    };
 
    class Monitor : public api::utils::perf::Monitor {
        private:
            mutable std::unordered_map<std::string, std::pair<std::size_t, Duration>> data;
 
        public:
            void commit(api::utils::perf::Probe& probe) override;
            std::size_t callCount(std::string probe_label) const override;
            Duration totalDuration(std::string probe_label) const override;
            void clear() override;
    };
 
    class ProbeBehavior : public api::model::Behavior {
        private:
            api::utils::perf::Monitor& monitor;
            api::model::Behavior& behavior;
            mutable Probe probe;
 
        public:
            ProbeBehavior(
                    api::utils::perf::Monitor& monitor,
                    api::model::Behavior& behavior,
                    std::string probe_name
                    );
 
            void execute(api::model::Agent* agent) const override;
    };
}}}
 
namespace nlohmann {
    template<typename Rep, typename Ratio>
        struct adl_serializer<std::chrono::duration<Rep, Ratio>> {
            template<typename JsonType>
                static void to_json(JsonType& json, const std::chrono::duration<Rep, Ratio>& duration) {
                    json = duration.count();
                }
            template<typename JsonType>
                static void from_json(JsonType& json, std::chrono::duration<Rep, Ratio>& duration) {
                    duration = std::chrono::duration<Rep, Ratio>(json.template get<Rep>());
                }
        };
}
 
namespace fpmas { namespace io { namespace datapack {
 
    template<typename Rep, typename Ratio>
        struct Serializer<std::chrono::duration<Rep, Ratio>> {
            template<typename Pack>
                static std::size_t size(
                        const Pack& pack,
                        const std::chrono::duration<Rep, Ratio>&) {
                    return pack.template size<Rep>();
                }
            template<typename Pack>
                static void to_datapack(
                        Pack& pack,
                        const std::chrono::duration<Rep, Ratio>& duration) {
                    pack.put(duration.count());
                }
            template<typename Pack>
                static std::chrono::duration<Rep, Ratio> from_datapack(
                        const Pack& pack) {
                    return std::chrono::duration<Rep, Ratio>(pack.template get<Rep>());
                }
        };
}}}
 
namespace fpmas { namespace io {
    template<typename Rep, typename Ratio>
        struct CsvSerial<std::chrono::duration<Rep, Ratio>> {
            static std::string to_csv(const std::chrono::duration<Rep, Ratio>& duration) {
                std::ostringstream os;
                os << duration.count();
                return os.str();
            }
        };
}}
#endif