artis-test/src/tests/multithreading/simple/models.hpp

/**
 * @file tests/multithreading/simple/models.hpp
 * @author The ARTIS Development Team
 * See the AUTHORS or Authors.txt file
 */

/*
 * ARTIS - the multimodeling and simulation environment
 * This file is a part of the ARTIS environment
 *
 * Copyright (C) 2013-2019 ULCO http://www.univ-littoral.fr
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef TESTS_MULTITHREADING_SIMPLE_MODELS_HPP
#define TESTS_MULTITHREADING_SIMPLE_MODELS_HPP

#include <artis-star/common/time/DoubleTime.hpp>
#include <artis-star/kernel/pdevs/Dynamics.hpp>
#include <random>
#include <iostream>

namespace artis {
    namespace tests {
        namespace multithreading {
            namespace simple {

                void delay()
                {
                    for (unsigned int i = 0; i < 1000; ++i) {
                        std::vector < int > v;

                        for (unsigned int j = 1000; j > 0; --j) {
                            v.push_back(j);
                        }
                        std::sort(v.begin(), v.end());
                    }
                }

                struct State {
                    enum values {
                        STOP, UP, MAX, DOWN
                    };
                };

                struct Vehicle {
                    unsigned int index;
                    double v_max;
                    double acceleration;
                    State::values state;
                    artis::common::DoubleTime::type next_time;
                };

                struct GeneratorParameters {
                    double v_max;
                    double mean;
                    double stddev;
                    unsigned long seed;
                };

                class Generator
                        : public artis::pdevs::Dynamics<artis::common::DoubleTime, Generator, GeneratorParameters> {
                public:
                    struct outputs {
                        enum values {
                            OUT
                        };
                    };

                    Generator(const std::string& name,
                            const artis::pdevs::Context<artis::common::DoubleTime, Generator, GeneratorParameters>& context)
                            :
                            artis::pdevs::Dynamics<artis::common::DoubleTime, Generator, GeneratorParameters>(
                                    name, context),
                            _v_max(context.parameters().v_max),
                            _distribution(context.parameters().mean, context.parameters().stddev),
                            _v_max_distribution(0.5, 1.),
                            _port_distribution(0, 7)
                    {
                        _generator.seed(context.parameters().seed);

                        output_ports({{outputs::OUT, "out_1"}});
                        output_ports({{outputs::OUT + 1, "out_2"}});
                        output_ports({{outputs::OUT + 2, "out_3"}});
                        output_ports({{outputs::OUT + 3, "out_4"}});
                        output_ports({{outputs::OUT + 4, "out_5"}});
                        output_ports({{outputs::OUT + 5, "out_6"}});
                        output_ports({{outputs::OUT + 6, "out_7"}});
                        output_ports({{outputs::OUT + 7, "out_8"}});
                    }

                    ~Generator() override = default;

                    void dint(const artis::common::DoubleTime::type& t) override
                    {
                        _last_time = t;
                        _sigma = _distribution(_generator);
                        _sigma = _sigma <= 0 ? 0.1 : _sigma;

                        _next_v_max = _v_max * _v_max_distribution(_generator);
                        _next_port = _port_distribution(_generator);
                        ++_index;
                    }

                    void start(const artis::common::DoubleTime::type& t) override
                    {
                        _last_time = t;
                        _sigma = _distribution(_generator);
                        _sigma = _sigma <= 0 ? 0.1 : _sigma;
                        _next_v_max = _v_max * _v_max_distribution(_generator);
                        _next_port = _port_distribution(_generator);
                        _index = 1;
                    }

                    artis::common::DoubleTime::type
                    ta(const artis::common::DoubleTime::type& /* t */) const override { return _sigma; }

                    artis::common::Bag<artis::common::DoubleTime>
                    lambda(const artis::common::DoubleTime::type& t) const override
                    {
                        artis::common::Bag<artis::common::DoubleTime> bag;

                        if (t > 0) {
                            Vehicle vehicle = {_index, _next_v_max, 0.5, State::STOP, t};

                            bag.push_back(
                                    artis::common::ExternalEvent<artis::common::DoubleTime>(
                                            outputs::OUT + _next_port, vehicle));
                        }
                        return bag;
                    }

                    common::DoubleTime::type
                    lookahead(const common::DoubleTime::type& /* t */) const override
                    {
                        return _last_time + _sigma;
                    }

                private:
                    // parameters
                    double _v_max;

                    // state
                    artis::common::DoubleTime::type _sigma;
                    artis::common::DoubleTime::type _last_time;
                    std::default_random_engine _generator;
                    std::normal_distribution<double> _distribution;
                    std::uniform_real_distribution<double> _v_max_distribution;
                    std::uniform_int_distribution<int> _port_distribution;
                    double _next_v_max;
                    int _next_port;
                    unsigned int _index;
                };

                class Counter
                        : public artis::pdevs::Dynamics<artis::common::DoubleTime, Counter> {
                public:
                    struct inputs {
                        enum values {
                            IN
                        };
                    };

                    struct vars {
                        enum values {
                            COUNTER
                        };
                    };

                    Counter(const std::string& name,
                            const artis::pdevs::Context<artis::common::DoubleTime, Counter>& context)
                            :
                            artis::pdevs::Dynamics<artis::common::DoubleTime, Counter>(name,
                                    context)
                    {
                        input_port({inputs::IN, "in"});
                        observable({vars::COUNTER, "counter"});
                    }

                    ~Counter() override = default;

                    void
                    dext(const artis::common::DoubleTime::type& /* t */,
                            const artis::common::DoubleTime::type& /* e */,
                            const artis::common::Bag<artis::common::DoubleTime>& bag) override
                    {

//                        std::cout << t << ": " << _counter << std::endl;

                        _counter += bag.size();
                    }

                    void start(const artis::common::DoubleTime::type& /* t */) override
                    {
                        _counter = 0;
                    }

                    artis::common::DoubleTime::type
                    ta(const artis::common::DoubleTime::type& /* t */) const override
                    {
                        return artis::common::DoubleTime::infinity;
                    }

                    artis::common::Value
                    observe(const artis::common::DoubleTime::type& /* t */,
                            unsigned int index) const override
                    {
                        if (index == vars::COUNTER) {
                            return _counter;
                        } else {
                            return artis::common::Value();
                        }
                    }

                    common::DoubleTime::type
                    lookahead(const common::DoubleTime::type& /* t */) const override
                    {
                        return common::DoubleTime::infinity;
                    }

                private:
                    unsigned int _counter;
                };

                class Link :
                        public artis::pdevs::Dynamics<common::DoubleTime, Link> {
                public :
                    struct inputs {
                        enum values {
                            IN
                        };
                    };

                    struct outputs {
                        enum values {
                            OUT
                        };
                    };

                    Link(const std::string& name,
                            const artis::pdevs::Context<common::DoubleTime, Link>& context)
                            :artis::pdevs::Dynamics<common::DoubleTime, Link>(name, context)
                    {
                        input_port({inputs::IN, "in"});
                        output_port({outputs::OUT, "out"});
                    }

                    ~ Link() override = default;

                    void dint(const artis::common::DoubleTime::type& t) override
                    {
                        delay();

                        auto it = _vehicles.begin();

                        while (it != _vehicles.end()) {
                            if (it->next_time == t and it->state == State::STOP) {
                                _vehicles.erase(it);
                                it = _vehicles.begin();
                            } else {
                                ++it;
                            }
                        }
                        for (auto& vehicle: _vehicles) {
                            if (vehicle.next_time == t) {
                                switch (vehicle.state) {
                                case State::UP: {
                                    double duration = vehicle.v_max / vehicle.acceleration;
                                    double acceleration_distance =
                                            0.5 * vehicle.acceleration * duration * duration;

                                    vehicle.state = State::MAX;
                                    vehicle.next_time = t +
                                            (_length - 2 * acceleration_distance) / vehicle.v_max;
                                    break;
                                }
                                case State::MAX: {
                                    vehicle.state = State::DOWN;
                                    vehicle.next_time = t + vehicle.v_max / vehicle.acceleration;
                                    break;
                                }
                                case State::DOWN: {
                                    vehicle.state = State::STOP;
                                    vehicle.next_time = t;
                                    break;
                                }
                                case State::STOP: {
                                    assert(false);
                                    break;
                                }
                                }
                            }
                        }
                        update_sigma(t);
                    }

                    void dext(const artis::common::DoubleTime::type& t,
                            const artis::common::DoubleTime::type& /* e */,
                            const artis::common::Bag<artis::common::DoubleTime>& bag) override
                    {
                        std::for_each(bag.begin(), bag.end(),
                                [this, t](const common::ExternalEvent<common::DoubleTime>& event) {
                                    if (event.on_port(inputs::IN)) {
                                        Vehicle vehicle;

                                        event.data()(vehicle);
                                        vehicle.next_time =
                                                t + vehicle.v_max / vehicle.acceleration;
                                        vehicle.state = State::UP;
                                        _vehicles.push_back(vehicle);
                                    }
                                });
                        update_sigma(t);
                    }

                    artis::common::DoubleTime::type
                    ta(const artis::common::DoubleTime::type& /* t */) const override { return _sigma; }

                    artis::common::Bag<artis::common::DoubleTime>
                    lambda(const artis::common::DoubleTime::type& t) const override
                    {
                        artis::common::Bag<artis::common::DoubleTime> bag;

                        for (auto vehicle: _vehicles) {
                            if (vehicle.next_time == t and vehicle.state == State::STOP) {
                                bag.push_back(
                                        artis::common::ExternalEvent<artis::common::DoubleTime>(
                                                outputs::OUT, vehicle));
                            }
                        }
                        return bag;
                    }

                    void
                    start(const artis::common::DoubleTime::type& /* t */) override { }

                    common::DoubleTime::type
                    lookahead(const common::DoubleTime::type& t) const override
                    {
                        double eot = artis::common::DoubleTime::infinity;

                        for (auto vehicle: _vehicles) {
                            double eot_i = artis::common::DoubleTime::infinity;

                            if (vehicle.next_time == t and vehicle.state == State::STOP) {
                                eot_i = t;
                            } else if (vehicle.state == State::DOWN) {
                                eot_i = vehicle.next_time;
                            } else if (vehicle.state == State::MAX) {
                                eot_i = vehicle.next_time + vehicle.v_max / vehicle.acceleration;
                            } else if (vehicle.state == State::UP) {
                                double duration = vehicle.v_max / vehicle.acceleration;
                                double acceleration_distance =
                                        0.5 * vehicle.acceleration * duration * duration;

                                eot_i = vehicle.next_time
                                        + (_length - 2 * acceleration_distance) / vehicle.v_max
                                        + vehicle.v_max / vehicle.acceleration;
                            }
                            if (eot_i < eot) {
                                eot = eot_i;
                            }
                        }
                        return eot;
                    }

                private:
                    void update_sigma(const artis::common::DoubleTime::type& t)
                    {
                        if (_vehicles.empty()) {
                            _sigma = artis::common::DoubleTime::infinity;
                        } else {
                            _sigma = std::min_element(_vehicles.begin(), _vehicles.end(),
                                    [](const Vehicle& e1, const Vehicle& e2) {
                                        return e1.next_time < e2.next_time;
                                    })->next_time - t;
                        }
                    }

                    const double _length = 500;

                    std::deque<Vehicle> _vehicles;
                    artis::common::DoubleTime::type _sigma;
                };

            }
        }
    }
} // namespace artis tests multithreading simple

#endif