base_island.h

/*****************************************************************************
 *   Copyright (C) 2004-2015 The PaGMO development team,                     *
 *   Advanced Concepts Team (ACT), European Space Agency (ESA)               *
 *                                                                           *
 *   https://github.com/esa/pagmo                                            *
 *                                                                           *
 *   act@esa.int                                                             *
 *                                                                           *
 *   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 2 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, write to the                           *
 *   Free Software Foundation, Inc.,                                         *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
 *****************************************************************************/

#ifndef PAGMO_BASE_ISLAND_H
#define PAGMO_BASE_ISLAND_H

#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread/thread.hpp>
#include <cstddef>
#include <iostream>
#include <string>
#include <vector>

#include "config.h"
#include "algorithm/base.h"
#include "migration/base_r_policy.h"
#include "migration/base_s_policy.h"
#include "population.h"
#include "problem/base.h"
#include "serialization.h"
#include "types.h"

namespace pagmo
{
// Forward declarations.
class archipelago;
class base_island;

typedef boost::shared_ptr<base_island> base_island_ptr;


class __PAGMO_VISIBLE base_island
{
        public:
                friend class archipelago;
                base_island(const base_island &);
                explicit base_island(const algorithm::base &, const problem::base &, int,
                        const migration::base_s_policy &,
                        const migration::base_r_policy &);
                explicit base_island(const algorithm::base &, const population &,
                        const migration::base_s_policy &,
                        const migration::base_r_policy &);
                base_island &operator=(const base_island &);

                virtual base_island_ptr clone() const = 0;
                virtual ~base_island();

                std::string human_readable_terse() const;
                std::string human_readable() const;
                virtual std::string get_name() const;

                virtual void join() const;
                bool busy() const;
                void evolve(int = 1);
                void evolve_t(int);
                void interrupt();
                std::size_t get_evolution_time() const;
        protected:
                virtual void perform_evolution(const algorithm::base &, population &) const = 0;
                virtual void thread_entry();
                virtual void thread_exit();
        public:
                algorithm::base_ptr get_algorithm() const;
                void set_algorithm(const algorithm::base &);
                void set_x(population::size_type, const decision_vector &);
                void set_v(population::size_type, const decision_vector &);
                problem::base_ptr get_problem() const;
                population::size_type get_size() const;
                migration::base_s_policy_ptr get_s_policy() const;
                migration::base_r_policy_ptr get_r_policy() const;
                population get_population() const;
                void set_population(const population &);
        private:
                // NOTE: in the next code line, it should be std::vector<std::pair<population::size_type, archipelago::size_type> >,
                // but this creates problems as at this point archipelago::siz_type is not defined and cannot be!!!
                std::vector<std::pair<population::size_type, population::size_type> > accept_immigrants(std::vector<std::pair<population::size_type, population::individual_type> > &);
                std::vector<population::individual_type> get_emigrants();
                // Evolver thread object. This is a callable helper object used to launch an evolution for a given number of iterations.
                struct int_evolver;
                // Time-dependent evolver thread object. This is a callable helper object used to launch an evolution for a specified amount of time.
                struct t_evolver;
                // RAII threads hook object.
                struct raii_thread_hook;
                friend struct raii_thread_hook;
        protected:
                algorithm::base_ptr                     m_algo;
                population                              m_pop;
                archipelago                             *m_archi;
                std::size_t                             m_evo_time;
                migration::base_s_policy_ptr            m_s_policy;
                migration::base_r_policy_ptr            m_r_policy;
                boost::scoped_ptr<boost::thread>        m_evo_thread;
        private:
                friend class boost::serialization::access;
                template <class Archive>
                void serialize(Archive &ar, const unsigned int version)
                {
                        // Sync the island before doing anything.
                        join();
                        // TODO: Also, consider relation to save/load constructor data in island and mpi_island.
                        ar & m_algo;
                        ar & m_pop;
                        ar & m_evo_time;
                        ar & m_s_policy;
                        ar & m_r_policy;
                        boost::serialization::split_member(ar, *this, version);
                }
                template <class Archive>
                void save(Archive &, const unsigned int) const
                {}
                template <class Archive>
                void load(Archive &, const unsigned int)
                {
                        // Upon loading we are going to set the archi pointer and the evo thread to 0.
                        m_archi = 0;
                        m_evo_thread.reset(0);
                }
};

std::ostream __PAGMO_VISIBLE_FUNC &operator<<(std::ostream &, const base_island &);

// Fake problem and algorithm used in the (de)serialization of island pointers.
namespace problem
{

class island_init: public base
{
        public:
                island_init():base(1) {}
                base_ptr clone() const
                {
                        return base_ptr(new island_init(*this));
                }
        protected:
                void objfun_impl(fitness_vector &, const decision_vector &) const {}
};

}

namespace algorithm
{

class island_init: public base
{
        public:
                island_init():base() {}
                base_ptr clone() const
                {
                        return base_ptr(new island_init(*this));
                }
                void evolve(population &) const {}
};

}

}

BOOST_SERIALIZATION_ASSUME_ABSTRACT(pagmo::base_island)

#endif