artis-test/src/tests/mpi/graph_manager.hpp

/**
 * @file tests/mpi/graph_manager.cpp
 * @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_PDEVS_MPI_GRAPH_MANAGER_HPP
#define TESTS_PDEVS_MPI_GRAPH_MANAGER_HPP

#include <tests/multithreading/lifegame/models.hpp>
#include <tests/pdevs/graph_manager.hpp>
#include <tests/pdevs/models.hpp>

#include <artis-star/kernel/pdevs/mpi/Coordinator.hpp>
#include <artis-star/kernel/pdevs/mpi/ModelProxy.hpp>
#include <artis-star/kernel/pdevs/mpi/GraphManager.hpp>

#include <artis-star/kernel/pdevs/multithreading/Coordinator.hpp>

#include <artis-star/kernel/pdevs/Simulator.hpp>

#include <sstream>

// #include <tests/boost_graph/graph_defs.hpp>

namespace artis {
namespace tests {
namespace mpi {

class S1GraphManager : public artis::pdevs::mpi::GraphManager<common::DoubleTime>
{
public:
  enum submodels
  {
    OneA, OneB
  };
  enum outputs
  {
    OUT
  };

  S1GraphManager(common::Coordinator<common::DoubleTime> *coordinator,
                 const artis::common::NoParameters &parameters,
                 const artis::common::NoParameters &graph_parameters)
      :
      artis::pdevs::mpi::GraphManager<common::DoubleTime>(coordinator,
                                                          parameters,
                                                          graph_parameters),
      a("a1", parameters), b("b1", parameters)
  {
    add_child(OneA, &a);
    add_child(OneB, &b);

    coordinator->output_port({OUT, "out"});

    out({&a, pdevs::A::OUT}) >> in({&b, pdevs::B::IN});
    out({&b, pdevs::B::OUT}) >> out({coordinator, OUT});
  }

  ~S1GraphManager() override = default;

private:
  artis::pdevs::Simulator<common::DoubleTime, pdevs::A> a;
  artis::pdevs::Simulator<common::DoubleTime, pdevs::B> b;
};

class S2GraphManager :
    public artis::pdevs::mpi::GraphManager<common::DoubleTime>
{
public:
  enum submodels
  {
    OneA, OneB
  };
  enum inputs
  {
    IN
  };
  enum outputs
  {
    OUT
  };

  S2GraphManager(common::Coordinator<common::DoubleTime> *coordinator,
                 const artis::common::NoParameters &parameters,
                 const artis::common::NoParameters &graph_parameters)
      :
      artis::pdevs::mpi::GraphManager<common::DoubleTime>(coordinator,
                                                          parameters,
                                                          graph_parameters),
      a("a2", parameters), b("b2", parameters)
  {
    add_child(OneA, &a);
    add_child(OneB, &b);

    coordinator->input_port({IN, "in"});
    coordinator->output_port({OUT, "out"});

    in({coordinator, IN}) >> in({&a, pdevs::A::IN});
    out({&a, pdevs::A::OUT}) >> in({&b, pdevs::B::IN});
    out({&b, pdevs::B::OUT}) >> out({coordinator, OUT});
  }

  ~S2GraphManager() override = default;

private:
  artis::pdevs::Simulator<common::DoubleTime, pdevs::A> a;
  artis::pdevs::Simulator<common::DoubleTime, pdevs::B> b;
};

struct RootGraphManagerParameters
{
  std::vector<int> ranks;
};

class RootGraphManager
    : public artis::pdevs::GraphManager<common::DoubleTime,
                                        artis::common::NoParameters,
                                        RootGraphManagerParameters>
{
public:
  RootGraphManager(
      common::Coordinator<common::DoubleTime> *coordinator,
      const artis::common::NoParameters &parameters,
      const RootGraphManagerParameters &graph_parameters)
      :
      artis::pdevs::GraphManager<common::DoubleTime,
                                 artis::common::NoParameters,
                                 RootGraphManagerParameters>(
          coordinator, parameters, graph_parameters)
  {
    ModelProxy *previous = nullptr;
    unsigned int i = 0;

    for (auto it = graph_parameters.ranks.begin(); it != graph_parameters.ranks.end(); ++it) {
      std::stringstream ss;
      ModelProxy *model = nullptr;

      ss << "S" << *it;
      model = new ModelProxy(ss.str(), *it, false);
      models.push_back(model);
      add_child(i, model);
      if (i == 0) {
        model->add_out_port({S1GraphManager::OUT, "out"});
      } else {
        model->add_out_port({S2GraphManager::OUT, "out"});
        model->add_in_port({S2GraphManager::IN, "in"});
        if (i == 1) {
          out({previous, S1GraphManager::OUT}) >> in({model, S2GraphManager::IN});
        } else {
          out({previous, S2GraphManager::OUT}) >> in({model, S2GraphManager::IN});
        }
      }
      previous = model;
      ++i;
    }
  }

  ~RootGraphManager() override
  {
    std::for_each(models.begin(), models.end(), std::default_delete<ModelProxy>());
  }

private:
  typedef artis::pdevs::mpi::ModelProxy<common::DoubleTime> ModelProxy;
  typedef std::vector<ModelProxy *> ModelProxies;

  ModelProxies models;
};

/******************************************************************************/

class S1LocalGraphManager : public artis::pdevs::GraphManager<common::DoubleTime>
{
public:
  enum submodels
  {
    OneA, OneB
  };
  enum outputs
  {
    OUT
  };

  S1LocalGraphManager(common::Coordinator<common::DoubleTime> *coordinator,
                      const artis::common::NoParameters &parameters,
                      const artis::common::NoParameters &graph_parameters)
      :
      artis::pdevs::GraphManager<common::DoubleTime>(coordinator, parameters, graph_parameters),
      a("a1", parameters), b("b1", parameters)
  {
    add_child(OneA, &a);
    add_child(OneB, &b);

    coordinator->output_port({OUT, "out"});

    out({&a, pdevs::A::OUT}) >> in({&b, pdevs::B::IN});
    out({&b, pdevs::B::OUT}) >> out({coordinator, OUT});
  }

  ~S1LocalGraphManager() override = default;

  void init()
  {}

  void start(common::DoubleTime::type /* t */)
  {}

  void transition(const common::Models<common::DoubleTime> & /* receivers */,
                  common::DoubleTime::type /* t */)
  {}

private:
  artis::pdevs::Simulator<common::DoubleTime, pdevs::A> a;
  artis::pdevs::Simulator<common::DoubleTime, pdevs::B> b;
};

class S2LocalGraphManager :
    public artis::pdevs::GraphManager<common::DoubleTime>
{
public:
  enum submodels
  {
    OneA, OneB
  };
  enum inputs
  {
    IN
  };
  enum outputs
  {
    OUT
  };

  S2LocalGraphManager(common::Coordinator<common::DoubleTime> *coordinator,
                      const artis::common::NoParameters &parameters,
                      const artis::common::NoParameters &graph_parameters)
      :
      artis::pdevs::GraphManager<common::DoubleTime>(coordinator, parameters, graph_parameters),
      a("a2", parameters), b("b2", parameters)
  {
    add_child(OneA, &a);
    add_child(OneB, &b);

    coordinator->input_port({IN, "in"});
    coordinator->output_port({OUT, "out"});

    in({coordinator, IN}) >> in({&a, pdevs::A::IN});
    out({&a, pdevs::A::OUT}) >> in({&b, pdevs::B::IN});
    out({&b, pdevs::B::OUT}) >> out({coordinator, OUT});
  }

  ~S2LocalGraphManager() override = default;

  void init()
  {}

  void start(common::DoubleTime::type /* t */)
  {}

  void transition(const common::Models<common::DoubleTime> & /* receivers */,
                  common::DoubleTime::type /* t */)
  {}

private:
  artis::pdevs::Simulator<common::DoubleTime, pdevs::A> a;
  artis::pdevs::Simulator<common::DoubleTime, pdevs::B> b;
};

class RootLocalGraphManager :
    public artis::pdevs::GraphManager<common::DoubleTime,
                                      artis::common::NoParameters,
                                      RootGraphManagerParameters>
{
public:
  RootLocalGraphManager(
      common::Coordinator<common::DoubleTime> *coordinator,
      const artis::common::NoParameters &parameters,
      const RootGraphManagerParameters &graph_parameters)
      :
      artis::pdevs::GraphManager<common::DoubleTime,
                                 artis::common::NoParameters,
                                 RootGraphManagerParameters>(
          coordinator, parameters, graph_parameters),
      first("S0", artis::common::NoParameters(), artis::common::NoParameters())
  {
    Next *previous = nullptr;
    unsigned int i = 1;

    add_child(0, &first);
    for (auto rank: graph_parameters.ranks) {
      std::stringstream ss;
      Next *model = nullptr;

      ss << "S" << rank;
      model = new Next(ss.str(), artis::common::NoParameters(), artis::common::NoParameters());
      nexts.push_back(model);
      add_child(i, model);
      if (previous) {
        out({previous, S2GraphManager::OUT}) >> in({model, S2GraphManager::IN});
      }
      previous = model;
      ++i;
    }
    out({&first, S1GraphManager::OUT}) >> in({nexts[0], S2GraphManager::IN});
  }

  ~RootLocalGraphManager() override
  {
    std::for_each(nexts.begin(), nexts.end(),
                  std::default_delete<Next>());
  }

private:
  typedef artis::pdevs::Coordinator<common::DoubleTime, S1LocalGraphManager> First;
  typedef artis::pdevs::Coordinator<common::DoubleTime, S2LocalGraphManager> Next;
  typedef std::vector<Next *> Nexts;

  First first;
  Nexts nexts;
};

/******************************************************************************/

class RootMultithreadingGraphManager :
    public artis::pdevs::GraphManager<common::DoubleTime,
                                      artis::common::NoParameters,
                                      RootGraphManagerParameters>
{
  typedef artis::pdevs::multithreading::Coordinator<
      common::DoubleTime,
      RootMultithreadingGraphManager,
      artis::common::NoParameters,
      RootGraphManagerParameters> ParentCoordinator;

public:
  RootMultithreadingGraphManager(
      common::Coordinator<common::DoubleTime> *coordinator,
      const artis::common::NoParameters &parameters,
      const RootGraphManagerParameters &graph_parameters)
      :
      artis::pdevs::GraphManager<common::DoubleTime,
                                 artis::common::NoParameters,
                                 RootGraphManagerParameters>(
          coordinator, parameters, graph_parameters),
      first("S0", artis::common::NoParameters(), artis::common::NoParameters())
  {
    Next *previous = nullptr;
    unsigned int i = 1;

    add_child(0, &first);
    for (auto rank: graph_parameters.ranks) {
      std::stringstream ss;
      Next *model = nullptr;

      ss << "S" << rank;
      model = new Next(ss.str(), artis::common::NoParameters(), artis::common::NoParameters());
      nexts.push_back(model);
      add_child(i, model);
      if (previous) {
        out({previous, S2GraphManager::OUT}) >> in({model, S2GraphManager::IN});
      }
      previous = model;
      ++i;
    }
    out({&first, S1GraphManager::OUT}) >> in({nexts[0], S2GraphManager::IN});
  }

  ~RootMultithreadingGraphManager() override
  {
    std::for_each(nexts.begin(), nexts.end(), std::default_delete<Next>());
  }

  void init()
  {
    first.set_sender(dynamic_cast < ParentCoordinator * >(coordinator())->get_sender());
    for (Nexts::const_iterator it = nexts.begin(); it != nexts.end(); ++it) {
      (*it)->set_sender(dynamic_cast < ParentCoordinator *  >(coordinator())->get_sender());
    }
  }

  void start(common::DoubleTime::type t)
  {
    first.get_sender().send(
        artis::pdevs::multithreading::start_message<
            artis::common::DoubleTime>(t));
    for (Nexts::const_iterator it = nexts.begin(); it != nexts.end(); ++it) {
      (*it)->get_sender().send(
          artis::pdevs::multithreading::start_message<artis::common::DoubleTime>(t));
    }
  }

  void transition(const common::Models<common::DoubleTime> &receivers,
                  artis::common::DoubleTime::type t)
  {
    auto it = receivers.begin();

    while (it != receivers.end()) {
      if (not(*it)->is_atomic()) {
        Nexts::const_iterator itc = std::find(nexts.begin(), nexts.end(), *it);

        if (itc != nexts.end()) {
          (*itc)->get_sender().send(
              artis::pdevs::multithreading::transition_message<
                  artis::common::DoubleTime>(t));
        } else {
          first.get_sender().send(
              artis::pdevs::multithreading::transition_message<
                  artis::common::DoubleTime>(t));
        }
      }
      ++it;
    }
  }

private:
  typedef artis::pdevs::multithreading::Coordinator<common::DoubleTime, S1LocalGraphManager> First;
  typedef artis::pdevs::multithreading::Coordinator<common::DoubleTime, S2LocalGraphManager> Next;
  typedef std::vector<Next *> Nexts;

  First first;
  Nexts nexts;
};

/******************************************************************************/

struct GridGraphManagerParameters
{
  unsigned int global_size;
  unsigned int sub_grid_size;
};

//            class GridGraphManager :
//                    public artis::pdevs::GraphManager<common::DoubleTime,
//                            GridGraphManagerParameters> {
//            public:
//                GridGraphManager(
//                        common::Coordinator<common::DoubleTime>* coordinator,
//                        const GridGraphManagerParameters& parameters)
//                        :
//                        artis::pdevs::GraphManager<common::DoubleTime,
//                                GridGraphManagerParameters>(
//                                coordinator, parameters)
//                {
//                    int index = 1;
//                    unsigned int size = parameters.global_size / parameters.sub_grid_size;
//
//                    // models
//                    for (unsigned int j = 0; j < size; ++j) {
//                        for (unsigned int i = 0; i < size; ++i) {
//                            std::stringstream ss;
//                            ModelProxy* model = 0;
//
//                            ss << "S_" << i << "_" << j;
//                            model = new ModelProxy(ss.str(), index++, false);
//                            models.push_back(model);
//                            add_child(model);
//                        }
//                    }
//
//                    // input ports
//                    for (unsigned int i = 0; i < size; ++i) {
//                        for (unsigned int j = 0; j < size; ++j) {
//                            ModelProxy* model = models[i + j * size];
//
//                            // top and bottom
//                            for (unsigned int x = i * parameters.sub_grid_size;
//                                 x < (i + 1) * parameters.sub_grid_size; ++x) {
//                                // top
//                                if (j != 0) {
//                                    std::stringstream ss;
//
//                                    ss << "in_" << x << "_"
//                                       << (j * parameters.sub_grid_size - 1);
//
//                                    // std::cout << "ADD INPUT PORT "
//                                    //           << model->get_name() << " "
//                                    //           << ss.str() << std::endl;
//
//                                    model->add_in_port(ss.str());
//                                }
//                                // bottom
//                                if (j != size - 1) {
//                                    std::stringstream ss;
//
//                                    ss << "in_" << x << "_"
//                                       << ((j + 1) * parameters.sub_grid_size);
//
//                                    // std::cout << "ADD INPUT PORT "
//                                    //           << model->get_name() << " "
//                                    //           << ss.str() << std::endl;
//
//                                    model->add_in_port(ss.str());
//                                }
//                            }
//                            // left and right
//                            for (unsigned int y = j * parameters.sub_grid_size;
//                                 y < (j + 1) * parameters.sub_grid_size; ++y) {
//
//                                // left
//                                if (i != 0) {
//                                    std::stringstream ss;
//
//                                    ss << "in_" << (i * parameters.sub_grid_size - 1)
//                                       << "_" << y;
//
//                                    // std::cout << "ADD INPUT PORT "
//                                    //           << model->get_name() << " "
//                                    //           << ss.str() << std::endl;
//
//                                    model->add_in_port(ss.str());
//                                }
//                                // right
//                                if (i != size - 1) {
//                                    std::stringstream ss;
//
//                                    ss << "in_" << ((i + 1) * parameters.sub_grid_size)
//                                       << "_" << y;
//
//                                    // std::cout << "ADD INPUT PORT "
//                                    //           << model->get_name() << " "
//                                    //           << ss.str() << std::endl;
//
//                                    model->add_in_port(ss.str());
//                                }
//                            }
//                        }
//                    }
//
//                    // output ports
//                    for (unsigned int i = 0; i < size; ++i) {
//                        for (unsigned int j = 0; j < size; ++j) {
//                            ModelProxy* model = models[i + j * size];
//
//                            // top and bottom
//                            for (unsigned int x = i * parameters.sub_grid_size;
//                                 x < (i + 1) * parameters.sub_grid_size; ++x) {
//                                // top
//                                if (j != 0) {
//                                    std::stringstream ss;
//
//                                    ss << "out_" << x << "_"
//                                       << (j * parameters.sub_grid_size);
//
//                                    // std::cout << "ADD OUTPUT PORT "
//                                    //           << model->get_name() << " "
//                                    //           << ss.str() << std::endl;
//
//                                    model->add_out_port(ss.str());
//                                }
//                                // bottom
//                                if (j != size - 1) {
//                                    std::stringstream ss;
//
//                                    ss << "out_" << x << "_"
//                                       << ((j + 1) * parameters.sub_grid_size - 1);
//
//                                    // std::cout << "ADD OUTPUT PORT "
//                                    //           << model->get_name() << " "
//                                    //           << ss.str() << std::endl;
//
//                                    model->add_out_port(ss.str());
//                                }
//                            }
//                            // left and right
//                            for (unsigned int y = j * parameters.sub_grid_size;
//                                 y < (j + 1) * parameters.sub_grid_size; ++y) {
//                                // left
//                                if (i != 0) {
//                                    std::stringstream ss;
//
//                                    ss << "out_" << (i * parameters.sub_grid_size)
//                                       << "_" << y;
//                                    if (not model->exist_out_port(ss.str())) {
//
//                                        // std::cout << "ADD OUTPUT PORT "
//                                        //           << model->get_name() << " "
//                                        //           << ss.str() << std::endl;
//
//                                        model->add_out_port(ss.str());
//                                    }
//                                }
//                                // right
//                                if (i != size - 1) {
//                                    std::stringstream ss;
//
//                                    ss << "out_" << ((i + 1) * parameters.sub_grid_size - 1)
//                                       << "_" << y;
//                                    if (not model->exist_out_port(ss.str())) {
//
//                                        // std::cout << "ADD OUTPUT PORT "
//                                        //           << model->get_name() << " "
//                                        //           << ss.str() << std::endl;
//
//                                        model->add_out_port(ss.str());
//                                    }
//                                }
//                            }
//                        }
//                    }
//
//                    // connections
//                    for (unsigned int i = 0; i < size; ++i) {
//                        for (unsigned int j = 0; j < size; ++j) {
//                            ModelProxy* model = models[i + j * size];
//
//                            // top
//                            if (j != 0) {
//                                for (unsigned int x = i * parameters.sub_grid_size;
//                                     x < (i + 1) * parameters.sub_grid_size; ++x) {
//                                    std::stringstream out_ss;
//                                    std::stringstream in_ss;
//
//                                    out_ss << "out_" << x << "_"
//                                           << (j * parameters.sub_grid_size - 1);
//                                    in_ss << "in_" << x << "_"
//                                          << (j * parameters.sub_grid_size - 1);
//
//                                    // std::cout << "LINK " << model->get_name()
//                                    //           << "::" << in_ss.str()
//                                    //           << " <= "
//                                    //           << models[i + (j - 1) * size]->get_name()
//                                    //           << "::"
//                                    //           << out_ss.str()
//                                    //           << std::endl;
//
//                                    add_link(models[i + (j - 1) * size], out_ss.str(),
//                                            model, in_ss.str());
//                                }
//                            }
//                            // bottom
//                            if (j != size - 1) {
//                                for (unsigned int x = i * parameters.sub_grid_size;
//                                     x < (i + 1) * parameters.sub_grid_size; ++x) {
//                                    std::stringstream out_ss;
//                                    std::stringstream in_ss;
//
//                                    out_ss << "out_" << x << "_"
//                                           << ((j + 1) * parameters.sub_grid_size);
//                                    in_ss << "in_" << x << "_"
//                                          << ((j + 1) * parameters.sub_grid_size);
//
//                                    // std::cout << "LINK " << model->get_name()
//                                    //           << "::" << in_ss.str()
//                                    //           << " <= "
//                                    //           << models[i + (j + 1) * size]->get_name()
//                                    //           << "::"
//                                    //           << out_ss.str()
//                                    //           << std::endl;
//
//                                    add_link(models[i + (j + 1) * size], out_ss.str(),
//                                            model, in_ss.str());
//                                }
//                            }
//                            // left
//                            if (i != 0) {
//                                for (unsigned int y = j * parameters.sub_grid_size;
//                                     y < (j + 1) * parameters.sub_grid_size; ++y) {
//                                    std::stringstream out_ss;
//                                    std::stringstream in_ss;
//
//                                    out_ss << "out_" << (i * parameters.sub_grid_size - 1)
//                                           << "_" << y;
//                                    in_ss << "in_" << (i * parameters.sub_grid_size - 1)
//                                          << "_" << y;
//
//                                    // std::cout << "LINK " << model->get_name()
//                                    //           << "::" << in_ss.str()
//                                    //           << " <= "
//                                    //           << models[i - 1 + j * size]->get_name()
//                                    //           << "::"
//                                    //           << out_ss.str()
//                                    //           << std::endl;
//
//                                    add_link(models[i - 1 + j * size], out_ss.str(),
//                                            model, in_ss.str());
//                                }
//                            }
//                            // right
//                            if (i != size - 1) {
//                                for (unsigned int y = j * parameters.sub_grid_size;
//                                     y < (j + 1) * parameters.sub_grid_size; ++y) {
//                                    std::stringstream out_ss;
//                                    std::stringstream in_ss;
//
//                                    out_ss << "out_"
//                                           << ((i + 1) * parameters.sub_grid_size)
//                                           << "_" << y;
//                                    in_ss << "in_"
//                                          << ((i + 1) * parameters.sub_grid_size)
//                                          << "_" << y;
//
//                                    // std::cout << "LINK " << model->get_name()
//                                    //           << "::" << in_ss.str()
//                                    //           << " <= "
//                                    //           << models[i + 1 + j * size]->get_name()
//                                    //           << "::"
//                                    //           << out_ss.str()
//                                    //           << std::endl;
//
//                                    add_link(models[i + 1 + j * size], out_ss.str(),
//                                            model, in_ss.str());
//                                }
//                            }
//                        }
//                    }
//                }
//
//                virtual ~GridGraphManager()
//                {
//                    std::for_each(models.begin(), models.end(),
//                            std::default_delete<ModelProxy>());
//                }
//
//            private:
//                typedef artis::pdevs::mpi::ModelProxy<common::DoubleTime> ModelProxy;
//                typedef std::vector<ModelProxy*> ModelProxies;
//
//                ModelProxies models;
//            };
//
//            struct SubGridGraphManagerParameters {
//                unsigned int global_size;
//                unsigned int begin_line;
//                unsigned int end_line;
//                unsigned int begin_column;
//                unsigned int end_column;
//            };
//
//            class SubGridGraphManager :
//                    public artis::pdevs::mpi::GraphManager<
//                            common::DoubleTime, SubGridGraphManagerParameters> {
//            public:
//                SubGridGraphManager(
//                        common::Coordinator<common::DoubleTime>* coordinator,
//                        const SubGridGraphManagerParameters& parameters)
//                        :
//                        artis::pdevs::mpi::GraphManager<
//                                common::DoubleTime, SubGridGraphManagerParameters>(coordinator,
//                                parameters)
//                {
//                    unsigned int size = parameters.end_column - parameters.begin_column + 1;
//
//                    for (unsigned int y = parameters.begin_line;
//                         y <= parameters.end_line; ++y) {
//                        for (unsigned int x = parameters.begin_column;
//                             x <= parameters.end_column; ++x) {
//                            std::stringstream ss;
//                            Simulator* simulator = 0;
//                            artis::tests::multithreading::lifegame::CellParameters
//                                    cell_parameters(
//                                    ((x != 0) ? 1 : 0) +
//                                            ((x != parameters.global_size - 1) ? 1 : 0) +
//                                            ((y != 0) ? 1 : 0) +
//                                            ((y != parameters.global_size - 1) ? 1 : 0));
//
//                            ss << "C_" << x << "_" << y;
//                            simulator = new Simulator(ss.str(), cell_parameters);
//                            simulators.push_back(simulator);
//                            add_child(simulator);
//                            simulator->add_out_port("out");
//                            simulator->add_in_port("in");
//                        }
//                    }
//                    // internal connections
//                    for (unsigned int x = parameters.begin_column;
//                         x <= parameters.end_column; ++x) {
//                        for (unsigned int y = parameters.begin_line;
//                             y <= parameters.end_line; ++y) {
//                            unsigned int i = x - parameters.begin_column;
//                            unsigned int j = y - parameters.begin_line;
//                            Simulator* simulator = simulators[i + j * size];
//
//                            if (i != 0) {
//                                add_link(simulators[(i - 1) + j * size], "out",
//                                        simulator, "in");
//
//                                // std::cout << "subgrid [ " << parameters.begin_column
//                                //           << " " << parameters.begin_line << " ] => "
//                                //           << ((i - 1) + j * size) << " -> "
//                                //           << (i + j * size) << std::endl;
//
//                            }
//                            if (i != size - 1) {
//                                add_link(simulators[(i + 1) + j * size], "out",
//                                        simulator, "in");
//
//                                // std::cout << "subgrid [ " << parameters.begin_column
//                                //           << " " << parameters.begin_line << " ] => "
//                                //           << ((i + 1) + j * size) << " -> "
//                                //           << (i + j * size) << std::endl;
//
//                            }
//                            if (j != 0) {
//                                add_link(simulators[i + (j - 1) * size], "out",
//                                        simulator, "in");
//
//                                // std::cout << "subgrid [ " << parameters.begin_column
//                                //           << " " << parameters.begin_line << " ] => "
//                                //           << (i + (j - 1) * size) << " -> "
//                                //           << (i + j * size) << std::endl;
//
//                            }
//                            if (j != size - 1) {
//                                add_link(simulators[i + (j + 1) * size], "out",
//                                        simulator, "in");
//
//                                // std::cout << "subgrid [ " << parameters.begin_column
//                                //           << " " << parameters.begin_line << " ] => "
//                                //           << (i + (j + 1) * size) << " -> "
//                                //           << (i + j * size) << std::endl;
//
//                            }
//                        }
//                    }
//                    // input ports
//                    {
//                        // top and bottom
//                        for (unsigned int x = parameters.begin_column;
//                             x <= parameters.end_column; ++x) {
//                            unsigned int i = x - parameters.begin_column;
//
//                            // top
//                            if (parameters.begin_line != 0) {
//                                std::stringstream ss;
//
//                                ss << "in_" << x << "_" << (parameters.begin_line - 1);
//                                coordinator->add_in_port(ss.str());
//                                add_link(coordinator, ss.str(), simulators[i], "in");
//                            }
//                            // bottom
//                            if (parameters.end_line != parameters.global_size - 1) {
//                                std::stringstream ss;
//
//                                ss << "in_" << x << "_" << (parameters.end_line + 1);
//                                coordinator->add_in_port(ss.str());
//                                add_link(coordinator, ss.str(),
//                                        simulators[i + size * (size - 1)], "in");
//                            }
//                        }
//                        // left and right
//                        for (unsigned int y = parameters.begin_line;
//                             y <= parameters.end_line; ++y) {
//                            unsigned int j = y - parameters.begin_line;
//
//                            // left
//                            if (parameters.begin_column != 0) {
//                                std::stringstream ss;
//
//                                ss << "in_" << (parameters.begin_column - 1) << "_" << y;
//                                coordinator->add_in_port(ss.str());
//                                add_link(coordinator, ss.str(), simulators[j * size], "in");
//                            }
//                            // right
//                            if (parameters.end_column != parameters.global_size - 1) {
//                                std::stringstream ss;
//
//                                ss << "in_" << (parameters.end_column + 1) << "_" << y;
//                                coordinator->add_in_port(ss.str());
//                                add_link(coordinator, ss.str(),
//                                        simulators[size - 1 + j * size], "in");
//
//                                // std::cout << "subgrid [ " << parameters.begin_column
//                                //           << " " << parameters.begin_line << " ] => "
//                                //           << ss.str() << " -> "
//                                //           << (size - 1 + j * size) << std::endl;
//
//                            }
//                        }
//                    }
//                    // output ports
//                    {
//                        // top and bottom
//                        for (unsigned int x = parameters.begin_column;
//                             x <= parameters.end_column; ++x) {
//                            unsigned int i = x - parameters.begin_column;
//
//                            // top
//                            {
//                                std::stringstream ss;
//
//                                ss << "out_" << x << "_" << parameters.begin_line;
//                                coordinator->add_out_port(ss.str());
//                                add_link(simulators[i], "out", coordinator, ss.str());
//
//                                // std::cout << "subgrid [ " << parameters.begin_column
//                                //           << " " << parameters.begin_line << " ] => "
//                                //           << simulators[i]->get_name()
//                                //           << "::out => " << ss.str() << std::endl;
//
//                            }
//                            // bottom
//                            {
//                                std::stringstream ss;
//
//                                ss << "out_" << x << "_" << parameters.end_line;
//                                coordinator->add_out_port(ss.str());
//                                add_link(simulators[i + size * (size - 1)], "out",
//                                        coordinator, ss.str());
//
//                                // std::cout << "subgrid [ " << parameters.begin_column
//                                //           << " " << parameters.begin_line << " ] => "
//                                //           << simulators[i + size * (size - 1)]->get_name()
//                                //           << "::out => " << ss.str() << std::endl;
//
//                            }
//                        }
//                        // left and right
//                        for (unsigned int y = parameters.begin_line;
//                             y <= parameters.end_line; ++y) {
//                            unsigned int j = y - parameters.begin_line;
//
//                            // left
//                            {
//                                std::stringstream ss;
//
//                                ss << "out_" << parameters.begin_column << "_" << y;
//                                if (not coordinator->exist_out_port(ss.str())) {
//                                    coordinator->add_out_port(ss.str());
//                                    add_link(simulators[j * size], "out",
//                                            coordinator, ss.str());
//
//                                    // std::cout << "subgrid [ " << parameters.begin_column
//                                    //       << " " << parameters.begin_line << " ] => "
//                                    //       << simulators[j * size]->get_name()
//                                    //       << "::out => " << ss.str() << std::endl;
//
//                                }
//                            }
//                            // right
//                            {
//                                std::stringstream ss;
//
//                                ss << "out_" << parameters.end_column << "_" << y;
//                                if (not coordinator->exist_out_port(ss.str())) {
//                                    coordinator->add_out_port(ss.str());
//                                    add_link(simulators[size - 1 + j * size], "out",
//                                            coordinator, ss.str());
//                                }
//                            }
//                        }
//                    }
//                }
//
//                void init() { }
//
//                void start(common::DoubleTime::type /* t */) { }
//
//                void transition(
//                        const common::Models<common::DoubleTime>& /* receivers */,
//                        common::DoubleTime::type /* t */) { }
//
//                virtual ~SubGridGraphManager()
//                {
//                    std::for_each(simulators.begin(), simulators.end(),
//                            std::default_delete<Simulator>());
//                }
//
//            private:
//                typedef artis::pdevs::Simulator<
//                        common::DoubleTime,
//                        multithreading::lifegame::Cell,
//                        multithreading::lifegame::CellParameters> Simulator;
//
//                typedef std::vector<Simulator*> Simulators;
//
//                Simulators simulators;
//            };

// struct MPIHierarchicalGraphManagerParameters
// {
//     artis::tests::boost_graph::OrientedGraphs graphs;
//     artis::tests::boost_graph::InputEdgeList input_edges;
//     artis::tests::boost_graph::OutputEdgeList output_edges;
//     artis::tests::boost_graph::Connections parent_connections;
//     std::vector < int > ranks;
// };

// class MPIHierarchicalGraphManager :
//         public artis::pdevs::GraphManager <
//     common::DoubleTime, MPIHierarchicalGraphManagerParameters >
// {
// public:
//     MPIHierarchicalGraphManager(
//         common::Coordinator < common::DoubleTime >* coordinator,
//         const MPIHierarchicalGraphManagerParameters& parameters) :
//         artis::pdevs::GraphManager <
//             common::DoubleTime,
//             MPIHierarchicalGraphManagerParameters >
//         (coordinator, parameters)
//     {
//         // build model proxies (graphs)
//         for (unsigned int i = 0; i < parameters.graphs.size(); ++i) {
//             ModelProxy* model = 0;
//             std::ostringstream ss;

//             ss << "S" << i;
//             model = new ModelProxy(ss.str(), parameters.ranks[i], false);
//             _models.push_back(model);
//             add_child(model);
//         }

//         // // builds internal connections (edges)
//         // for (Connections::const_iterator it = parent_connections.begin();
//         //      it != parent_connections.end(); ++it) {
//         //     const Connection& connection = *it;
//         //     std::ostringstream ss_out;
//         //     std::ostringstream ss_in;

//         //     ss_out << "out_" << connection.first.second;
//         //     ss_in << "in_" << connection.first.second;

//         //     if (not ParallelHeapHierarchicalGraphManager <
//         //             GraphBuilder >::exist_link(
//         //                 _coordinators[connection.first.first - 1],
//         //                 ss_out.str(),
//         //                 _coordinators[connection.second.first - 1],
//         //                 ss_in.str())) {
//         //         ParallelHeapHierarchicalGraphManager <
//         //             GraphBuilder >::add_link(
//         //                 _coordinators[connection.first.first - 1],
//         //                 ss_out.str(),
//         //                 _coordinators[connection.second.first - 1],
//         //                 ss_in.str());
//         //     }
//         // }
//     }

//     virtual ~MPIHierarchicalGraphManager()
//     {
//         for (typename ModelProxies::const_iterator it = _models.begin();
//              it != _models.end(); ++it) {
//             delete *it;
//         }
//     }

// private:
//     typedef artis::pdevs::mpi::ModelProxy < common::DoubleTime > ModelProxy;
//     typedef std::vector < ModelProxy* > ModelProxies;

//     ModelProxies _models;
// };

}
}
} // namespace artis tests mpi

#endif