From cf561b537a0e8ec7edd178700b9f9e8de021b5c8 Mon Sep 17 00:00:00 2001
From: quemy <alexandre.quemy@gmail.com>
Date: Sun, 11 Nov 2012 22:36:21 +0100
Subject: [PATCH] Add islandNotifier to allow the mig and int policy to be
 checked in the island. The islandNotifier is added to the algorithm
 continuator and will make the island perform a binded task. In the case of
 island, the task is to check policies.

---
 smp/src/abstractIsland.h                      | 71 +++++++++++++++++++
 smp/src/contWrapper.cpp                       | 36 ++++++++++
 smp/src/contWrapper.h                         | 20 ++++--
 smp/src/intPolicy.cpp                         | 35 +++++++++
 smp/src/intPolicy.h                           | 68 ++++++++++++++++++
 smp/src/island.cpp                            | 36 ++++++++--
 smp/src/island.h                              | 43 +++++++++--
 smp/src/islandNotifier.cpp                    | 41 +++++++++++
 smp/src/islandNotifier.h                      | 68 ++++++++++++++++++
 smp/src/migPolicy.h                           | 53 ++------------
 smp/src/policyElement.cpp                     | 61 ++++++++++++++++
 .../{migPolicyElement.h => policyElement.h}   | 48 ++++++-------
 smp/src/smp.h                                 |  4 +-
 smp/test/t-smpIsland.cpp                      |  7 +-
 14 files changed, 498 insertions(+), 93 deletions(-)
 create mode 100644 smp/src/abstractIsland.h
 create mode 100644 smp/src/contWrapper.cpp
 create mode 100644 smp/src/intPolicy.cpp
 create mode 100644 smp/src/intPolicy.h
 create mode 100644 smp/src/islandNotifier.cpp
 create mode 100644 smp/src/islandNotifier.h
 create mode 100644 smp/src/policyElement.cpp
 rename smp/src/{migPolicyElement.h => policyElement.h} (71%)

diff --git a/smp/src/abstractIsland.h b/smp/src/abstractIsland.h
new file mode 100644
index 000000000..2c04465ea
--- /dev/null
+++ b/smp/src/abstractIsland.h
@@ -0,0 +1,71 @@
+/*
+<abstractIsland.h>
+Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
+
+Alexandre Quemy, Thibault Lasnier - INSA Rouen
+
+This software is governed by the CeCILL license under French law and
+abiding by the rules of distribution of free software.  You can  ue,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+Contact: paradiseo-help@lists.gforge.inria.fr
+*/
+
+#ifndef ABS_ISLAND_H_
+#define ABS_ISLAND_H_
+
+#include <eo>
+#include <migPolicy.h>
+
+namespace paradiseo
+{
+namespace smp
+{
+
+/** AbstractIsland: An abstract island.
+
+@see smp::Island
+*/
+
+template<class EOT>
+class AIsland
+{
+public:
+    /**
+     * Send population to mediator
+     * @param _select Method to select EOT to send
+     */
+    virtual void send(eoSelect<EOT>& _select) = 0;
+    
+    /**
+     * Check if there is population to receive
+     */
+    virtual void receive(void) = 0;
+    
+    /**
+     * Check if there is population to receive or to emigrate
+     */
+    virtual void check(void) = 0;
+};
+
+}
+
+}
+
+#endif
diff --git a/smp/src/contWrapper.cpp b/smp/src/contWrapper.cpp
new file mode 100644
index 000000000..38737bcdc
--- /dev/null
+++ b/smp/src/contWrapper.cpp
@@ -0,0 +1,36 @@
+/*
+<contWrapper.cpp>
+Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
+
+Alexandre Quemy, Thibault Lasnier - INSA Rouen
+
+This software is governed by the CeCILL license under French law and
+abiding by the rules of distribution of free software.  You can  ue,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+Contact: paradiseo-help@lists.gforge.inria.fr
+*/
+
+template<class EOT>
+paradiseo::smp::ContWrapper<EOT>::ContWrapper(eoContinue<EOT>& _cont, AIsland<EOT>* island) :
+    ck(_cont),
+    islandNotifier(island, &AIsland<EOT>::check)
+{   
+    ck.add(islandNotifier);
+}
diff --git a/smp/src/contWrapper.h b/smp/src/contWrapper.h
index 3df93af9d..75cadbce6 100644
--- a/smp/src/contWrapper.h
+++ b/smp/src/contWrapper.h
@@ -36,26 +36,36 @@ Contact: paradiseo-help@lists.gforge.inria.fr
 
 #include <eo>
 #include <migPolicy.h>
+#include <islandNotifier.h>
 
 namespace paradiseo
 {
 namespace smp
 {
 
+/** ContWrapper: Utility class to wrap the algorithm continuators with island notifier.
+
+Utility class to wrap the algorithm continuators with island notifier during the island construction.
+
+*/
 template<class EOT>
 class ContWrapper
 {
 public:
-    ContWrapper(eoContinue<EOT>& _cont, Policy<EOT>& _policy) :
-        ck(_cont)
-    {
-        ck.add(_policy);
-    }
+    /**
+     * Constructor
+     * @param _cont Original continuators
+     * @param _policy Policy to wrap with continuators
+     */
+    ContWrapper(eoContinue<EOT>& _cont, AIsland<EOT>* island);
 
 protected:
     eoCheckPoint<EOT> ck;
+    IslandNotifier<EOT> islandNotifier;
 };
 
+#include <contWrapper.cpp>
+
 }
 
 }
diff --git a/smp/src/intPolicy.cpp b/smp/src/intPolicy.cpp
new file mode 100644
index 000000000..ca4664403
--- /dev/null
+++ b/smp/src/intPolicy.cpp
@@ -0,0 +1,35 @@
+/*
+<intPolicy.cpp>
+Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
+
+Alexandre Quemy, Thibault Lasnier - INSA Rouen
+
+This software is governed by the CeCILL license under French law and
+abiding by the rules of distribution of free software.  You can  ue,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+Contact: paradiseo-help@lists.gforge.inria.fr
+*/
+
+template <class EOT>
+paradiseo::smp::IntPolicy<EOT>::IntPolicy(eoEvalFunc<EOT>& _eval, eoReplacement<EOT>& _replace) :
+    eval(_eval),
+    replace(_replace)
+{}
+
diff --git a/smp/src/intPolicy.h b/smp/src/intPolicy.h
new file mode 100644
index 000000000..038b5f6e3
--- /dev/null
+++ b/smp/src/intPolicy.h
@@ -0,0 +1,68 @@
+/*
+<intPolicy.h>
+Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
+
+Alexandre Quemy, Thibault Lasnier - INSA Rouen
+
+This software is governed by the CeCILL license under French law and
+abiding by the rules of distribution of free software.  You can  ue,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+Contact: paradiseo-help@lists.gforge.inria.fr
+*/
+
+#ifndef INT_POLICY_H_
+#define INT_POLICY_H_
+
+#include <eo>
+
+namespace paradiseo
+{
+namespace smp
+{
+
+/** IntPolicy: Integration policy for island.
+
+The island model will check its policy to know how to integrate population sent by other islands.
+
+@see smp::Island, smp::MigPolicy
+*/
+
+template <class EOT>
+class IntPolicy
+{
+public:
+    /**
+     * Constructor
+     * @param _eval Method to evaluate the population to integrate.
+     * @param _replace Method to replace elements in the island.
+     */
+    IntPolicy(eoEvalFunc<EOT>& _eval, eoReplacement<EOT>& _replace);
+    
+    eoEvalFunc<EOT>& eval;
+    eoReplacement<EOT>& replace;
+};
+
+#include<intPolicy.cpp>
+
+}
+
+}
+
+#endif
diff --git a/smp/src/island.cpp b/smp/src/island.cpp
index da6066117..a7920d108 100644
--- a/smp/src/island.cpp
+++ b/smp/src/island.cpp
@@ -31,14 +31,18 @@ Contact: paradiseo-help@lists.gforge.inria.fr
 
 template<template <class> class EOAlgo, class EOT>
 template<class... Args>
-paradiseo::smp::Island<EOAlgo,EOT>::Island(unsigned _popSize, eoInit<EOT>& _chromInit, eoReplacement<EOT>& _intPolicy, Policy<EOT>& _migPolicy, Args&... args) :
-    ContWrapper<EOT>(Loop<Args...>().template findValue<eoContinue<EOT>>(args...),_migPolicy),
-    pop(_popSize, _chromInit),
+paradiseo::smp::Island<EOAlgo,EOT>::Island(unsigned _popSize, eoInit<EOT>& _chromInit, IntPolicy<EOT>& _intPolicy, MigPolicy<EOT>& _migPolicy, Args&... args) :
+    // The PPExpander looks for the continuator in the parameters pack.
+    // The private inheritance of ContWrapper wraps the continuator and add islandNotifier.
+    ContWrapper<EOT>(Loop<Args...>().template findValue<eoContinue<EOT>>(args...), this),
+    // We inject the wrapped continuator by tag dispatching method during the algorithm construction.
     algo(EOAlgo<EOT>(wrap_pp<eoContinue<EOT>>(this->ck,args)...)),
-    intPolicy(_intPolicy)
+    pop(_popSize, _chromInit),
+    intPolicy(_intPolicy),
+    migPolicy(_migPolicy)
 {
+    // Check in compile time the inheritance thanks to type_trait.
     static_assert(std::is_base_of<eoAlgo<EOT>,EOAlgo<EOT>>::value, "Algorithm must inherit from eoAlgo<EOT>");
-    _migPolicy.addObserver(this);  
 }
 
 template<template <class> class EOAlgo, class EOT>
@@ -59,6 +63,21 @@ eoPop<EOT>& paradiseo::smp::Island<EOAlgo,EOT>::getPop()
     return pop;
 }
 
+template<template <class> class EOAlgo, class EOT>
+void paradiseo::smp::Island<EOAlgo,EOT>::check()
+{
+    std::cout << "On check" << std::endl;
+    for(PolicyElement<EOT>& elem : migPolicy)
+    {
+        if(!elem(pop))
+        {
+            std::cout << "On lance l'emmigration" << std::endl;
+            send(elem.getSelect());
+        }
+    }
+    receive();    
+}
+
 template<template <class> class EOAlgo, class EOT>
 void paradiseo::smp::Island<EOAlgo,EOT>::send(eoSelect<EOT>& _select)
 {
@@ -73,8 +92,11 @@ void paradiseo::smp::Island<EOAlgo,EOT>::receive(void)
 {
     while (!listImigrants.empty())
     {
-        intPolicy(pop, *(listImigrants.front()));
+        eoPop<EOT> offspring = *(listImigrants.front());
+        for(auto indi : offspring)
+        
+        intPolicy.replace(pop, offspring);
         listImigrants.pop();
+        
     }
-
 }
diff --git a/smp/src/island.h b/smp/src/island.h
index a035905b0..11a0105ae 100644
--- a/smp/src/island.h
+++ b/smp/src/island.h
@@ -37,6 +37,7 @@ Contact: paradiseo-help@lists.gforge.inria.fr
 #include <eo>
 #include <abstractIsland.h>
 #include <migPolicy.h>
+#include <intPolicy.h>
 #include <PPExpander.h>
 #include <contWrapper.h>
 #include <contDispatching.h>
@@ -50,25 +51,57 @@ template<template <class> class EOAlgo, class EOT>
 class Island : private ContWrapper<EOT>, public AIsland<EOT>
 {
 public:
+    /**
+     * Constructor
+     * @param _popSize Size of the algorithm population.
+     * @param _chromInit Population initializer.
+     * @param _intPolicy Integration policy
+     * @param _migPolicy Migration policy
+     * @param args Parameters to construct the algorithm of the island.
+     */
     template<class... Args>
-    Island(unsigned _popSize, eoInit<EOT>& _chromInit, eoReplacement<EOT>& _intPolicy, Policy<EOT>& _migPolicy, Args&... args);
+    Island(unsigned _popSize, eoInit<EOT>& _chromInit, IntPolicy<EOT>& _intPolicy, MigPolicy<EOT>& _migPolicy, Args&... args);
     
+    /**
+     * Start the island.
+     */
     void operator()();
     
+    /**
+     * Update the list of imigrants.
+     * @param _data Elements to integrate in the main population.
+     */
     void update(eoPop<EOT>& _data);
     
+    /**
+     * Return a reference to the island population.
+     * @return Reference to the island population
+     */
     eoPop<EOT>& getPop();
     
-    //friend void Policy<EOT>::notifyIsland(eoSelect<EOT>& _select) const;
+    /**
+     * Check if there is population to receive or to migrate
+     */
+    virtual void check(void);
     
 protected:
-    void send(eoSelect<EOT>& _select);
-    void receive(void);
 
+    /**
+     * Send population to mediator
+     * @param _select Method to select EOT to send
+     */
+    virtual void send(eoSelect<EOT>& _select);
+    
+    /**
+     * Check if there is population to receive
+     */
+    virtual void receive(void);
+    
     eoPop<EOT> pop;
     EOAlgo<EOT> algo;
     std::queue<eoPop<EOT>*> listImigrants;
-    eoReplacement<EOT>& intPolicy;
+    IntPolicy<EOT>& intPolicy;
+    MigPolicy<EOT>& migPolicy;
 };
 
 #include <island.cpp>
diff --git a/smp/src/islandNotifier.cpp b/smp/src/islandNotifier.cpp
new file mode 100644
index 000000000..758e32b75
--- /dev/null
+++ b/smp/src/islandNotifier.cpp
@@ -0,0 +1,41 @@
+/*
+<islandNotifier.cpp>
+Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
+
+Alexandre Quemy, Thibault Lasnier - INSA Rouen
+
+This software is governed by the CeCILL license under French law and
+abiding by the rules of distribution of free software.  You can  ue,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+Contact: paradiseo-help@lists.gforge.inria.fr
+*/
+
+template <class EOT>
+paradiseo::smp::IslandNotifier<EOT>::IslandNotifier(AIsland<EOT>* _observer, std::function<void(AIsland<EOT>*)> _task) :
+    observer(_observer),
+    task(_task)
+{}
+    
+template <class EOT>
+void paradiseo::smp::IslandNotifier<EOT>::operator()()
+{
+    task(observer);
+}
+
diff --git a/smp/src/islandNotifier.h b/smp/src/islandNotifier.h
new file mode 100644
index 000000000..267f2897e
--- /dev/null
+++ b/smp/src/islandNotifier.h
@@ -0,0 +1,68 @@
+/*
+<islandNotifier.h>
+Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
+
+Alexandre Quemy, Thibault Lasnier - INSA Rouen
+
+This software is governed by the CeCILL license under French law and
+abiding by the rules of distribution of free software.  You can  ue,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+Contact: paradiseo-help@lists.gforge.inria.fr
+*/
+
+#ifndef ISLAND_NOTIFIER_H_
+#define ISLAND_NOTIFIER_H_
+
+#include <vector>
+#include <utility>
+
+/** IslandNotifier: The notifier will perform the binded task each generation.
+
+The island notifier makes the binded task executed by the island which observes.
+We can imagine that a continuator check is we have to execute the binded task.
+At the moment the task is perfermed each generation.
+
+*/
+
+namespace paradiseo
+{
+namespace smp
+{
+
+template <class EOT>
+class IslandNotifier : public eoUpdater
+{
+public :
+    IslandNotifier(AIsland<EOT>* _observer, std::function<void(AIsland<EOT>*)> _task);
+    
+    virtual void operator()();
+    
+protected :
+    AIsland<EOT>* observer;
+    std::function<void(AIsland<EOT>*)> task;
+};
+
+#include <islandNotifier.cpp>
+
+}
+
+}
+
+#endif
diff --git a/smp/src/migPolicy.h b/smp/src/migPolicy.h
index 6bd0dcea2..29ea6cc22 100644
--- a/smp/src/migPolicy.h
+++ b/smp/src/migPolicy.h
@@ -30,61 +30,18 @@ Contact: paradiseo-help@lists.gforge.inria.fr
 #ifndef MIG_POLICY_H_
 #define MIG_POLICY_H_
 
-#include <set>
-
 #include <eo>
-#include <migPolicyElement.h>
-#include <island.h>
-#include <abstractIsland.h>
+#include <policyElement.h>
 
 namespace paradiseo
 {
 namespace smp
 {
-// Forward declaration
-template <class EOT>
-class AIsland;
+/** MigPolicy: Migration policy
+*/
 
-template <class EOT>
-class Policy : public eoContinue<EOT>, public std::vector<PolicyElement<EOT>>
-{
-public:
-    bool operator()(const eoPop<EOT>& _pop)
-    {
-        std::cout << "On regarde la politique de migration" << std::endl;
-        for(PolicyElement<EOT>& elem : *this)
-        {
-            std::cout << ".";
-            if(!elem(_pop))
-            {
-                std::cout << "On lance l'emmigration" << std::endl;
-                notifyIsland(elem.getSelect());
-            }
-        }     
-        return true; // Always return true because it never stops the algorithm
-    }
-    
-    void addObserver(AIsland<EOT>* _observer)
-    {
-        observers.insert(_observer);
-    }
- 
-    void removeObserver(AIsland<EOT>* _observer)
-    {
-        observers.erase(_observer);
-    }
-   
-protected:
-
-    void notifyIsland(eoSelect<EOT>& _select) const
-    {
-        std::cout << "On notifie les iles" << std::endl;
-        for (AIsland<EOT>* it : observers)
-            it->send(_select);
-    }
-
-    std::set<AIsland<EOT>*> observers;
-};
+template <class EOT> 
+using MigPolicy = std::vector<PolicyElement<EOT>>;
 
 }
 
diff --git a/smp/src/policyElement.cpp b/smp/src/policyElement.cpp
new file mode 100644
index 000000000..25d27051f
--- /dev/null
+++ b/smp/src/policyElement.cpp
@@ -0,0 +1,61 @@
+/*
+<policyElement.cpp>
+Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2012
+
+Alexandre Quemy, Thibault Lasnier - INSA Rouen
+
+This software is governed by the CeCILL license under French law and
+abiding by the rules of distribution of free software.  You can  ue,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+Contact: paradiseo-help@lists.gforge.inria.fr
+*/
+
+#include <eo>
+
+template <class EOT>
+paradiseo::smp::PolicyElement<EOT>::PolicyElement(eoSelect<EOT>& _selection, eoContinue<EOT>& _criteria) :
+    selection(_selection),
+    criteria(_criteria)
+{ }
+    
+template <class EOT>
+bool paradiseo::smp::PolicyElement<EOT>::operator()(const eoPop<EOT>& _pop)
+{
+    // DEBUG
+    static int i = 0;
+    std::cout << i << std::endl;   
+    i++;
+    // END DEBUG
+        
+    return criteria(_pop);
+}
+    
+template <class EOT>
+void paradiseo::smp::PolicyElement<EOT>::addCriteria(eoContinue<EOT>& _criteria)
+{
+    criteria.add(_criteria);
+}
+    
+template <class EOT>
+eoSelect<EOT>& paradiseo::smp::PolicyElement<EOT>::getSelect() 
+{
+    return selection;
+}
+
diff --git a/smp/src/migPolicyElement.h b/smp/src/policyElement.h
similarity index 71%
rename from smp/src/migPolicyElement.h
rename to smp/src/policyElement.h
index 15f37aeb8..9d1545bcb 100644
--- a/smp/src/migPolicyElement.h
+++ b/smp/src/policyElement.h
@@ -41,39 +41,39 @@ template <class EOT>
 class PolicyElement : public eoContinue<EOT>
 {
 public :
-    PolicyElement(eoSelect<EOT>& _selection, eoContinue<EOT>& _criteria) :
-        selection(_selection),
-        criteria(_criteria)
-    {
-        
-    }
+    /**
+     * Constructor
+     * @param _selection How to select elements for migration
+     * @param _criteria When notifying the island
+     */
+    PolicyElement(eoSelect<EOT>& _selection, eoContinue<EOT>& _criteria);
     
-    bool operator()(const eoPop<EOT>& _pop)
-    {
-        // DEBUG
-        static int i = 0;
-        std::cout << i << std::endl;   
-        i++;
-        // END DEBUG
-        
-        return criteria(_pop);
-    }
+    /**
+     * Check is the criteria is reach
+     * @param _pop Population which is checked by the criteria.
+     * @return false if the criteria is reached.
+     */
+    bool operator()(const eoPop<EOT>& _pop);
     
-    void addCriteria(eoContinue<EOT>& _criteria)
-    {
-        criteria.add(_criteria);
-    }
+    /**
+     * Add criteria for the same selection method.
+     * @param _criteria New criteria.
+     */
+    void addCriteria(eoContinue<EOT>& _criteria);
     
-    eoSelect<EOT>& getSelect() 
-    {
-        return selection;
-    }
+     /**
+     * Access to the selection method.
+     * @return Reference to the selection method.
+     */
+    eoSelect<EOT>& getSelect();
     
 protected :
     eoSelect<EOT>& selection;
     eoContinue<EOT>& criteria;
 };
 
+#include <policyElement.cpp>
+
 }
 
 }
diff --git a/smp/src/smp.h b/smp/src/smp.h
index de986ee7f..ff22c9a21 100644
--- a/smp/src/smp.h
+++ b/smp/src/smp.h
@@ -35,6 +35,8 @@ Contact: paradiseo-help@lists.gforge.inria.fr
 #include <scheduler.h>
 #include <island.h>
 #include <migPolicy.h>
-#include <migPolicyElement.h>
+#include <intPolicy.h>
+#include <policyElement.h>
+#include <islandNotifier.h>
 
 #endif
diff --git a/smp/test/t-smpIsland.cpp b/smp/test/t-smpIsland.cpp
index f89820d0f..ce7ab58bc 100644
--- a/smp/test/t-smpIsland.cpp
+++ b/smp/test/t-smpIsland.cpp
@@ -53,10 +53,11 @@ int main(void)
         eoPeriodicContinue<Indi> criteria(25); // We mig each gen
         eoDetTournamentSelect<Indi> selectOne(2);
         eoSelectNumber<Indi> who(selectOne, 5);
-        Policy<Indi> pol;
-        pol.push_back(PolicyElement<Indi>(who, criteria));
+        MigPolicy<Indi> migPolicy;
+        migPolicy.push_back(PolicyElement<Indi>(who, criteria));
+        IntPolicy<Indi> intPolicy(plainEval,replace);
         
-        Island<eoEasyEA,Indi> test(param.popSize, chromInit, replace, pol, genCont, plainEval, select, transform, replace);
+        Island<eoEasyEA,Indi> test(param.popSize, chromInit, intPolicy, migPolicy, genCont, plainEval, select, transform, replace);
         
         test();
         cout << test.getPop() << endl;