Initial import.

git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@1986 331e1502-861f-0410-8da2-ba01fb791d7f

ParadisEO-GPU/tutoriel/OneMax/CMakeLists.txt

@@ -0,0 +1,60 @@
+###############################################################################
+##
+## CMakeLists file for OneMax Example/application
+##
+###############################################################################
+
+
+######################################################################################
+### 1) Include the sources
+######################################################################################
+
+INCLUDE_DIRECTORIES(
+
  # include CUDA source directory
+  ${CUDA_SRC_DIR}
+  # include NVIDIA source directory
+  ${NVIDIA_SRC_DIR}
+  # include EO source directory
+  ${PARADISEO_EO_SRC_DIR}/src
+  # include MO source directory
+  ${PARADISEO_MO_SRC_DIR}/src
+  # include problems  directory
+  ${PARADISEO_PROBLEMS_SRC_DIR}
+  # include GPU  directory
+  ${PARADISEO_GPU_SRC_DIR}
+  # include your source directory
+  ${CMAKE_CURRENT_SOURCE_DIR}/../src
+  )
+
+######################################################################################
+
+######################################################################################
+### 2) Specify where CMake can find the libraries
+######################################################################################
+
+LINK_DIRECTORIES(${PARADISEO_EO_BIN_DIR}/lib  ${NVIDIA_LIB_DIR} ${CUDA_LIB_DIR} )	
+
+######################################################################################
+
+######################################################################################
+### 3) Define your targets and link the librairies
+######################################################################################	
+			
+#CUDA_ADD_EXECUTABLE(Cutest test.cu) 
+CUDA_ADD_EXECUTABLE(CutestFirstImpr testFirstImpr.cu) 
+CUDA_ADD_EXECUTABLE(CutestNeutralHC testNeutralHC.cu) 
+CUDA_ADD_EXECUTABLE(CutestSimpleHC testSimpleHC.cu) 
+CUDA_ADD_EXECUTABLE(CutestSimpleTS testSimpleTS.cu) 
+CUDA_ADD_EXECUTABLE(CutestSimulatedAnnealing testSimulatedAnnealing.cu) 
+CUDA_ADD_EXECUTABLE(CutestKswapHC testKswapHC.cu)
+
+#TARGET_LINK_LIBRARIES(Cutest eoutils ga eo libcutil.a)
+TARGET_LINK_LIBRARIES(CutestFirstImpr eoutils ga eo libcutil.a)
+TARGET_LINK_LIBRARIES(CutestNeutralHC eoutils ga eo libcutil.a)
+TARGET_LINK_LIBRARIES(CutestSimpleHC eoutils ga eo libcutil.a)
+TARGET_LINK_LIBRARIES(CutestSimpleTS eoutils ga eo libcutil.a)
+TARGET_LINK_LIBRARIES(CutestSimulatedAnnealing eoutils ga eo libcutil.a)
+TARGET_LINK_LIBRARIES(CutestKswapHC eoutils ga eo libcutil.a)
+
+
+######################################################################################

ParadisEO-GPU/tutoriel/OneMax/testFirstImpr.cu

@@ -0,0 +1,222 @@
+//Init the number of threads per block
+#define BLOCK_SIZE 128
+
+#include <iostream>  
+#include <stdlib.h> 
+using namespace std;
+
+// The general include for eo
+#include <eo>
+#include <ga.h>
+// Fitness function
+#include <problems/eval/EvalOneMax.h>
+// Cuda Fitness function
+#include <eval/moCudaVectorEval.h>
+#include <problems/eval/OneMaxIncrEval.h>
+// One Max solution
+#include <cudaType/moCudaBitVector.h>
+//To compute execution time
+#include <performance/moCudaTimer.h>
+// One Max neighbor
+#include <neighborhood/moCudaBitNeighbor.h>
+// One Max ordered neighborhood
+#include <neighborhood/moCudaOrderNeighborhood.h>
+// The Solution and neighbor comparator
+#include <comparator/moNeighborComparator.h>
+#include <comparator/moSolNeighborComparator.h>
+// The continuator
+#include <continuator/moTrueContinuator.h>
+// Local search algorithm
+#include <algo/moLocalSearch.h>
+// First improvment algorithm
+#include <algo/moFirstImprHC.h>
+// The First Improvment algorithm explorer
+#include <explorer/moFirstImprHCexplorer.h>
+
+// REPRESENTATION
+typedef moCudaBitVector<eoMaximizingFitness> solution;
+typedef moCudaBitNeighbor <solution,eoMaximizingFitness> Neighbor;
+typedef moCudaOrderNeighborhood<Neighbor> Neighborhood;
+
+void main_function(int argc, char **argv)
+{
+  /* =========================================================
+   *
+   * Parameters
+   *
+   * ========================================================= */
+
+  // First define a parser from the command-line arguments
+  eoParser parser(argc, argv);
+
+  // For each parameter, define Parameter, read it through the parser,
+  // and assign the value to the variable
+
+  // seed
+  eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+  parser.processParam( seedParam );
+  unsigned seed = seedParam.value();
+
+  // description of genotype
+  eoValueParam<unsigned int> vecSizeParam(8, "vecSize", "Genotype size", 'V');
+  parser.processParam( vecSizeParam, "Representation" );
+  unsigned vecSize = vecSizeParam.value();
+
+  // the name of the "status" file where all actual parameter values will be saved
+  string str_status = parser.ProgramName() + ".status"; // default value
+  eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
+  parser.processParam( statusParam, "Persistence" );
+
+  // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
+  // i.e. in case you need parameters somewhere else, postpone these
+  if (parser.userNeedsHelp()) {
+    parser.printHelp(cout);
+    exit(1);
+  }
+  if (statusParam.value() != "") {
+    ofstream os(statusParam.value().c_str());
+    os << parser;// and you can use that file as parameter file
+  }
+
+  /* =========================================================
+   *
+   * Random seed
+   *
+   * ========================================================= */
+
+  //reproducible random seed: if you don't change SEED above,
+  // you'll aways get the same result, NOT a random run
+  rng.reseed(seed);
+  int seed1=time(0);
+  srand(seed1);
+  
+  /* =========================================================
+   *
+   * Initilisation of the solution
+   *
+   * ========================================================= */
+  
+  solution sol(vecSize);
+  if(vecSize<64)
+    for(unsigned i=0;i<vecSize;i++) cout<<sol[i]<<"  ";
+  cout<<endl;
+
+  /* =========================================================
+   *
+   * Eval fitness function
+   *
+   * ========================================================= */
+
+  EvalOneMax<solution> eval;
+  
+  /* =========================================================
+   *
+   * Evaluation of a solution neighbor's
+   *
+   * ========================================================= */
+
+  OneMaxIncrEval<Neighbor> incr_eval;
+  moCudaVectorEval<Neighbor,OneMaxIncrEval<Neighbor> > cueval(vecSize,incr_eval);
+  
+  /* =========================================================
+   *
+   * Comparator of solutions and neighbors
+   *
+   * ========================================================= */
+
+  moNeighborComparator<Neighbor> comparator;
+  moSolNeighborComparator<Neighbor> solComparator;
+
+  /* =========================================================
+   *
+   * a solution neighborhood
+   *
+   * ========================================================= */
+
+  Neighborhood neighborhood(vecSize,cueval);
+
+  /* =========================================================
+   *
+   * An explorer of solution neighborhood's
+   *
+   * ========================================================= */
+
+  moFirstImprHCexplorer<Neighbor> explorer(neighborhood, cueval, comparator, solComparator);
+
+
+  /* =========================================================
+   *
+   * The local search algorithm
+   *
+   * ========================================================= */
+  // True continuator <=> Always continue
+
+  moTrueContinuator<Neighbor> continuator;
+
+  moLocalSearch<Neighbor> localSearch(explorer,continuator, eval);
+
+  /* =========================================================
+   *
+   * The First improvment algorithm
+   *
+   * ========================================================= */
+
+  moFirstImprHC<Neighbor> firstImprHC(neighborhood,eval,cueval);
+
+  /* =========================================================
+   *
+   * Execute the local search from random sollution
+   *
+   * ========================================================= */
+
+  //Can be eval here, else it will be done at the beginning of the localSearch
+  eval(sol);
+
+  std::cout << "initial: " << sol.fitness()<< std::endl;
+  moCudaTimer timer;
+  timer.start();
+  localSearch(sol);
+  timer.stop();
+  printf("CUDA execution time = %f ms\n",timer.getTime());
+  timer.deleteTimer();
+  std::cout << "final:   " << sol.fitness() << std::endl;
+  
+  /* =========================================================
+   *
+   * Execute the first improvment from random sollution
+   *
+   * ========================================================= */
+ 
+  solution sol1(vecSize);
+  if(vecSize<64)
+    for(unsigned i=0;i<vecSize;i++) cout<<sol1[i]<<"  ";
+  cout<<endl;
+  cout<<endl;
+
+  eval(sol1);
+
+  std::cout << "initial: " << sol1.fitness()<< std::endl;
+
+  moCudaTimer timer1;
+  timer1.start();
+  firstImprHC(sol1);
+  timer1.stop();
+  printf("CUDA execution time = %f ms\n",timer1.getTime());
+  timer1.deleteTimer();
+
+  std::cout << "final:   " << sol1.fitness() << std::endl;
+
+}
+
+// A main that catches the exceptions
+
+int main(int argc, char **argv)
+{
+  try{
+    main_function(argc, argv);
+  }
+  catch(exception& e){
+    cout << "Exception: " << e.what() << '\n';
+  }
+  return 1;
+}

ParadisEO-GPU/tutoriel/OneMax/testNeutralHC.cu

@@ -0,0 +1,180 @@
+//Init the number of threads per block
+#define BLOCK_SIZE 128
+#include <iostream>  
+#include <stdlib.h> 
+using namespace std;
+
+// The general include for eo
+#include <eo>
+#include <ga.h>
+// Fitness function
+#include <problems/eval/EvalOneMax.h>
+// Cuda Fitness function
+#include <eval/moCudaVectorEval.h>
+#include <problems/eval/OneMaxIncrEval.h>
+// One Max solution
+#include <cudaType/moCudaBitVector.h>
+//To compute execution time
+#include <performance/moCudaTimer.h>
+// One Max neighbor
+#include <neighborhood/moCudaBitNeighbor.h>
+// One Max ordered neighborhood
+#include <neighborhood/moCudaOrderNeighborhood.h>
+// The Solution and neighbor comparator
+#include <comparator/moNeighborComparator.h>
+#include <comparator/moSolNeighborComparator.h>
+// The continuator
+#include <continuator/moTrueContinuator.h>
+// Simple HC algorithm
+#include <algo/moNeutralHC.h>
+
+
+// REPRESENTATION
+typedef moCudaBitVector<eoMaximizingFitness> solution;
+typedef moCudaBitNeighbor <solution,eoMaximizingFitness> Neighbor;
+typedef moCudaOrderNeighborhood<Neighbor> Neighborhood;
+
+void main_function(int argc, char **argv)
+{
+
+  /* =========================================================
+   *
+   * Parameters
+   *
+   * ========================================================= */
+
+  // First define a parser from the command-line arguments
+  eoParser parser(argc, argv);
+
+  // For each parameter, define Parameter, read it through the parser,
+  // and assign the value to the variable
+
+  // seed
+  eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+  parser.processParam( seedParam );
+  unsigned seed = seedParam.value();
+
+  // description of genotype
+  eoValueParam<unsigned int> vecSizeParam(8, "vecSize", "Genotype size", 'V');
+  parser.processParam( vecSizeParam, "Representation" );
+  unsigned vecSize = vecSizeParam.value();
+
+  //nbStep maximum step to do
+  eoValueParam<unsigned int> nbStepParam(10, "nbStep", "maximum number of step", 'N');
+  parser.processParam( nbStepParam, "numberStep" );
+  unsigned nbStep = nbStepParam.value();
+
+
+  // the name of the "status" file where all actual parameter values will be saved
+  string str_status = parser.ProgramName() + ".status"; // default value
+  eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
+  parser.processParam( statusParam, "Persistence" );
+
+  // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
+  // i.e. in case you need parameters somewhere else, postpone these
+  if (parser.userNeedsHelp()) {
+    parser.printHelp(cout);
+    exit(1);
+  }
+  if (statusParam.value() != "") {
+    ofstream os(statusParam.value().c_str());
+    os << parser;// and you can use that file as parameter file
+  }
+  /* =========================================================
+   *
+   * Random seed
+   *
+   * ========================================================= */
+
+  //reproducible random seed: if you don't change SEED above,
+  // you'll aways get the same result, NOT a random run
+  rng.reseed(seed);
+
+  
+  /* =========================================================
+   *
+   * Initilisation of the solution
+   *
+   * ========================================================= */
+  
+  solution sol(vecSize);
+  if(vecSize<64)
+    for(unsigned i=0;i<vecSize;i++) cout<<sol[i]<<"  ";
+  cout<<endl;
+
+  /* =========================================================
+   *
+   * Eval fitness function
+   *
+   * ========================================================= */
+
+  EvalOneMax<solution> eval;
+  
+  /* =========================================================
+   *
+   * Evaluation of a solution neighbor's
+   *
+   * ========================================================= */
+  
+  OneMaxIncrEval<Neighbor> incr_eval;
+  moCudaVectorEval<Neighbor,OneMaxIncrEval<Neighbor> > cueval(vecSize,incr_eval);
+  
+  /* =========================================================
+   *
+   * Comparator of solutions and neighbors
+   *
+   * ========================================================= */
+
+  moNeighborComparator<Neighbor> comparator;
+  moSolNeighborComparator<Neighbor> solComparator;
+
+  /* =========================================================
+   *
+   * a solution neighborhood
+   *
+   * ========================================================= */
+
+  Neighborhood neighborhood(vecSize,cueval);
+
+  /* =========================================================
+   *
+   * The simple Hill Climbing algorithm
+   *
+   * ========================================================= */
+  //True continuator <=> Always continue
+
+  moTrueContinuator<Neighbor> continuator;
+
+  moNeutralHC<Neighbor> neutralHC(neighborhood,eval,cueval,nbStep,continuator);
+
+  /* =========================================================
+   *
+   * Execute the neutralHill climbing from random sollution
+   *
+   * ========================================================= */
+  
+  eval(sol);
+
+  std::cout << "initial: " << sol.fitness()<< std::endl;
+  moCudaTimer timer;
+  timer.start();
+  neutralHC(sol);
+  timer.stop();
+  printf("CUDA execution time = %f ms\n",timer.getTime());
+  timer.deleteTimer();
+  std::cout << "final:   " << sol.fitness() << std::endl;
+
+}
+
+// A main that catches the exceptions
+
+int main(int argc, char **argv)
+{
+  try{
+    main_function(argc, argv);
+  }
+  catch(exception& e){
+    cout << "Exception: " << e.what() << '\n';
+  }
+  return 1;
+}

ParadisEO-GPU/tutoriel/OneMax/testSimpleHC.cu

@@ -0,0 +1,222 @@
+//Init the number of threads per block
+#define BLOCK_SIZE 128
+#include <iostream>  
+#include <stdlib.h> 
+using namespace std;
+
+// The general include for eo
+#include <eo>
+#include <ga.h>
+// Fitness function
+#include <problems/eval/EvalOneMax.h>
+// Cuda Fitness function
+#include <eval/moCudaVectorEval.h>
+#include <problems/eval/OneMaxIncrEval.h>
+// One Max solution
+#include <cudaType/moCudaBitVector.h>
+// One Max neighbor
+#include <neighborhood/moCudaBitNeighbor.h>
+//To compute execution time
+#include <performance/moCudaTimer.h>
+// One Max ordered neighborhood
+#include <neighborhood/moCudaOrderNeighborhood.h>
+// The Solution and neighbor comparator
+#include <comparator/moNeighborComparator.h>
+#include <comparator/moSolNeighborComparator.h>
+// The continuator
+#include <continuator/moTrueContinuator.h>
+// Local search algorithm
+#include <algo/moLocalSearch.h>
+// Simple HC algorithm
+#include <algo/moSimpleHC.h>
+// The simple HC algorithm explorer
+#include <explorer/moSimpleHCexplorer.h>
+
+// REPRESENTATION
+typedef moCudaBitVector<eoMaximizingFitness> solution;
+typedef moCudaBitNeighbor <solution> Neighbor;
+typedef moCudaOrderNeighborhood<Neighbor> Neighborhood;
+
+void main_function(int argc, char **argv)
+{
+
+  /* =========================================================
+   *
+   * Parameters
+   *
+   * ========================================================= */
+
+  // First define a parser from the command-line arguments
+  eoParser parser(argc, argv);
+
+  // For each parameter, define Parameter, read it through the parser,
+  // and assign the value to the variable
+
+  // seed
+  eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+  parser.processParam( seedParam );
+  unsigned seed = seedParam.value();
+
+  // description of genotype
+  eoValueParam<unsigned int> vecSizeParam(8, "vecSize", "Genotype size", 'V');
+  parser.processParam( vecSizeParam, "Representation" );
+  unsigned vecSize = vecSizeParam.value();
+
+  // the name of the "status" file where all actual parameter values will be saved
+  string str_status = parser.ProgramName() + ".status"; // default value
+  eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
+  parser.processParam( statusParam, "Persistence" );
+
+  // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
+  // i.e. in case you need parameters somewhere else, postpone these
+  if (parser.userNeedsHelp()) {
+    parser.printHelp(cout);
+    exit(1);
+  }
+  if (statusParam.value() != "") {
+    ofstream os(statusParam.value().c_str());
+    os << parser;// and you can use that file as parameter file
+  }
+  /* =========================================================
+   *
+   * Random seed
+   *
+   * ========================================================= */
+
+  //reproducible random seed: if you don't change SEED above,
+  // you'll aways get the same result, NOT a random run
+  rng.reseed(seed);
+
+  
+  /* =========================================================
+   *
+   * Initilisation of the solution
+   *
+   * ========================================================= */
+  
+  solution sol(vecSize);
+  if(vecSize<64)
+    for(unsigned i=0;i<vecSize;i++) cout<<sol[i]<<"  ";
+  cout<<endl;
+
+  /* =========================================================
+   *
+   * Eval fitness function
+   *
+   * ========================================================= */
+
+  EvalOneMax<solution> eval;
+  
+  /* =========================================================
+   *
+   * Evaluation of a solution neighbor's
+   *
+   * ========================================================= */
+  
+  OneMaxIncrEval<Neighbor> incr_eval;
+  moCudaVectorEval<Neighbor,OneMaxIncrEval<Neighbor> > cueval(vecSize,incr_eval);
+  
+  /* =========================================================
+   *
+   * Comparator of solutions and neighbors
+   *
+   * ========================================================= */
+
+  moNeighborComparator<Neighbor> comparator;
+  moSolNeighborComparator<Neighbor> solComparator;
+
+  /* =========================================================
+   *
+   * a solution neighborhood
+   *
+   * ========================================================= */
+
+  Neighborhood neighborhood(vecSize,cueval);
+
+  /* =========================================================
+   *
+   * An explorer of solution neighborhood's
+   *
+   * ========================================================= */
+
+  moSimpleHCexplorer<Neighbor> explorer(neighborhood, cueval,
+					comparator, solComparator);
+
+  /* =========================================================
+   *
+   * The local search algorithm
+   *
+   * ========================================================= */
+  //True continuator <=> Always continue
+
+  moTrueContinuator<Neighbor> continuator;
+
+  moLocalSearch<Neighbor> localSearch(explorer,continuator, eval);
+
+  /* =========================================================
+   *
+   * The simple Hill Climbing algorithm
+   *
+   * ========================================================= */
+
+  moSimpleHC<Neighbor> simpleHC(neighborhood,eval,cueval);
+
+  /* =========================================================
+   *
+   * Execute the local search from random sollution
+   *
+   * ========================================================= */
+ 
+  //Can be eval here, else it will be done at the beginning of the localSearch
+  eval(sol);
+
+  std::cout << "initial: " << sol.fitness()<< std::endl;
+  // Create timer for timing CUDA calculation
+  moCudaTimer timer;
+  timer.start();
+  localSearch(sol);
+  timer.stop();
+  printf("CUDA execution time = %f ms\n",timer.getTime());
+  timer.deleteTimer();
+  std::cout << "final:   " << sol.fitness() << std::endl;
+
+  /* =========================================================
+   *
+   * Execute the Simple Hill climbing from random sollution
+   *
+   * ========================================================= */
+  solution sol1(vecSize);
+  if(vecSize<64)
+    for(unsigned i=0;i<vecSize;i++) cout<<sol1[i]<<"  ";
+  cout<<endl;
+  cout<<endl;
+
+
+  eval(sol1);
+
+  std::cout << "initial: " << sol1.fitness()<< std::endl;
+  // Create timer for timing CUDA calculation
+  moCudaTimer timer1;
+  timer1.start();
+  simpleHC(sol1);
+  timer1.stop();
+  printf("CUDA execution time = %f ms\n",timer1.getTime());
+  timer1.deleteTimer();
+  std::cout << "final:   " << sol1.fitness() << std::endl;
+
+
+
+}
+
+// A main that catches the exceptions
+
+int main(int argc, char **argv)
+{
+  try{
+    main_function(argc, argv);
+  }
+  catch(exception& e){
+    cout << "Exception: " << e.what() << '\n';
+  }
+  return 1;
+}

ParadisEO-GPU/tutoriel/OneMax/testSimpleTS.cu

@@ -0,0 +1,282 @@
+//Init the number of threads per block
+#define BLOCK_SIZE 128
+
+#include <iostream>  
+#include <stdlib.h> 
+using namespace std;
+
+// The general include for eo
+#include <eo>
+#include <ga.h>
+// Fitness function
+#include <problems/eval/EvalOneMax.h>
+// Cuda Fitness function
+#include <eval/moCudaVectorEval.h>
+#include <problems/eval/OneMaxIncrEval.h>
+// One Max solution
+#include <cudaType/moCudaBitVector.h>
+//To compute execution time
+#include <performance/moCudaTimer.h>
+// One Max neighbor
+#include <neighborhood/moCudaBitNeighbor.h>
+// One Max ordered neighborhood
+#include <neighborhood/moCudaOrderNeighborhood.h>
+// The Solution and neighbor comparator
+#include <comparator/moNeighborComparator.h>
+#include <comparator/moSolNeighborComparator.h>
+// The time continuator
+#include <continuator/moTimeContinuator.h>
+// Local search algorithm
+#include <algo/moLocalSearch.h>
+// The Tabou Search algorithm explorer
+#include <explorer/moTSexplorer.h>
+//Algorithm and its components
+#include <algo/moTS.h>
+//Tabu list
+#include <memory/moNeighborVectorTabuList.h>
+//Memories
+#include <memory/moDummyIntensification.h>
+#include <memory/moDummyDiversification.h>
+#include <memory/moBestImprAspiration.h>
+
+
+
+// REPRESENTATION
+
+typedef moCudaBitVector<eoMaximizingFitness> solution;
+typedef moCudaBitNeighbor <solution,eoMaximizingFitness> Neighbor;
+typedef moCudaOrderNeighborhood<Neighbor> Neighborhood;
+
+
+void main_function(int argc, char **argv)
+{
+  /* =========================================================
+   *
+   * Parameters
+   *
+   * ========================================================= */
+
+  // First define a parser from the command-line arguments
+  eoParser parser(argc, argv);
+
+  // For each parameter, define Parameter, read it through the parser,
+  // and assign the value to the variable
+
+  // seed
+  eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+  parser.processParam( seedParam );
+  unsigned seed = seedParam.value();
+
+  // description of genotype
+  eoValueParam<unsigned int> vecSizeParam(8, "vecSize", "Genotype size", 'V');
+  parser.processParam( vecSizeParam, "Representation" );
+  unsigned vecSize = vecSizeParam.value();
+
+  // size tabu list
+  eoValueParam<unsigned int> sizeTabuListParam(7, "sizeTabuList", "size of the tabu list", 'T');
+  parser.processParam( sizeTabuListParam, "Search Parameters" );
+  unsigned sizeTabuList = sizeTabuListParam.value();
+
+  // time Limit
+  eoValueParam<unsigned int> timeLimitParam(1, "timeLimit", "time limits", 't');
+  parser.processParam( timeLimitParam, "Search Parameters" );
+  unsigned timeLimit = timeLimitParam.value();
+
+  // the name of the "status" file where all actual parameter values will be saved
+  string str_status = parser.ProgramName() + ".status"; // default value
+  eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
+  parser.processParam( statusParam, "Persistence" );
+
+  // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
+  // i.e. in case you need parameters somewhere else, postpone these
+  if (parser.userNeedsHelp()) {
+    parser.printHelp(cout);
+    exit(1);
+  }
+  if (statusParam.value() != "") {
+    ofstream os(statusParam.value().c_str());
+    os << parser;// and you can use that file as parameter file
+  }
+  /* =========================================================
+   *
+   * Random seed
+   *
+   * ========================================================= */
+
+  //reproducible random seed: if you don't change SEED above,
+  // you'll aways get the same result, NOT a random run
+  rng.reseed(seed);
+
+  /* =========================================================
+   *
+   * Eval fitness function
+   *
+   * ========================================================= */
+
+  EvalOneMax<solution> eval;
+  
+  /* =========================================================
+   *
+   * Evaluation of a solution neighbor's
+   *
+   * ========================================================= */
+  
+  OneMaxIncrEval<Neighbor> incr_eval;
+  moCudaVectorEval<Neighbor,OneMaxIncrEval<Neighbor> > cueval(vecSize,incr_eval);
+
+  /* =========================================================
+   *
+   * Comparator of solutions and neighbors
+   *
+   * ========================================================= */
+
+  moNeighborComparator<Neighbor> comparator;
+  moSolNeighborComparator<Neighbor> solComparator;
+
+  /* =========================================================
+   *
+   * a solution neighborhood
+   *
+   * ========================================================= */
+
+  Neighborhood neighborhood(vecSize,cueval);
+    
+  /* =========================================================
+   *
+   * continuator
+   *
+   * ========================================================= */
+
+  moTimeContinuator <Neighbor> continuator(timeLimit);
+
+  /* =========================================================
+   *
+   * tabu list
+   *
+   * ========================================================= */
+
+  //moNeighborVectorTabuList<shiftNeighbor> tl(sizeTabuList,0);
+  // tabu list
+  moNeighborVectorTabuList<Neighbor> tl(sizeTabuList,0);
+
+  /* =========================================================
+   *
+   * Memories
+   *
+   * ========================================================= */
+
+  moDummyIntensification<Neighbor> inten;
+  moDummyDiversification<Neighbor> div;
+  moBestImprAspiration<Neighbor> asp;
+
+  /* =========================================================
+   *
+   * An explorer of solution neighborhood's
+   *
+   * ========================================================= */
+
+  moTSexplorer<Neighbor> explorer(neighborhood, cueval, comparator, solComparator, tl, inten, div, asp);
+
+  
+  /* =========================================================
+   *
+   * the local search algorithm
+   *
+   * ========================================================= */
+
+  moLocalSearch<Neighbor> localSearch1(explorer, continuator, eval);
+
+  //Basic Constructor
+  moTS<Neighbor> localSearch2(neighborhood,eval, cueval,  2, 7);
+
+  //Simple Constructor
+  moTS<Neighbor> localSearch3(neighborhood, eval, cueval, 5, tl);
+
+  //General Constructor
+  moTS<Neighbor> localSearch4(neighborhood, eval, cueval, comparator, solComparator, continuator, tl, inten, div, asp);
+
+  /* =========================================================
+   *
+   * Execute the local search(TS) from random sollution
+   *
+   * ========================================================= */
+  //Initilisation of the solution
+  solution sol1(vecSize);
+  eval(sol1);
+  std::cout << "Tabu Search 1:" << std::endl;
+  std::cout << "---------------------" << std::endl;
+  std::cout << "initial: " << sol1.fitness()<< std::endl;
+  moCudaTimer timer1;
+  timer1.start();
+  localSearch1(sol1);
+  timer1.stop();
+  printf("CUDA execution time = %f ms\n",timer1.getTime());
+  timer1.deleteTimer();
+  std::cout << "final:   " << sol1.fitness() << std::endl<<std::endl;
+  /* =========================================================
+   *
+   * Execute the TS Basic Constructor 
+   *
+   * ========================================================= */
+  solution sol2(vecSize);
+  eval(sol2);
+  std::cout << "Tabu Search 2:" << std::endl;
+  std::cout << "---------------------" << std::endl;
+  std::cout << "initial: " << sol2.fitness()<< std::endl;
+  moCudaTimer timer2;
+  timer2.start();
+  localSearch2(sol2);
+  timer2.stop();
+  printf("CUDA execution time = %f ms\n",timer2.getTime());
+  timer2.deleteTimer();
+  std::cout << "final:   " << sol2.fitness() << std::endl<< std::endl;
+  /* =========================================================
+   *
+   * Execute the TS Simple Constructor
+   *
+   * ========================================================= */
+  solution sol3(vecSize);
+  eval(sol3);
+  std::cout << "Tabu Search 3:" << std::endl;
+  std::cout << "---------------------" << std::endl;
+  std::cout << "initial: " << sol3.fitness()<< std::endl;
+  moCudaTimer timer3;
+  timer3.start();
+  localSearch3(sol3);
+  timer3.stop();
+  printf("CUDA execution time = %f ms\n",timer3.getTime());
+  timer3.deleteTimer();
+  std::cout << "final:   " << sol3.fitness() << std::endl<< std::endl;
+  /* =========================================================
+   *
+   * Execute the TS General Constructor
+   *
+   * ========================================================= */
+  solution sol4(vecSize);
+  eval(sol4);
+  std::cout << "Tabu Search 4:" << std::endl;
+  std::cout << "---------------------" << std::endl;
+  std::cout << "initial: " << sol4.fitness()<< std::endl;
+  moCudaTimer timer4;
+  timer4.start();
+  localSearch4(sol4);
+  timer4.stop();
+  printf("CUDA execution time = %f ms\n",timer4.getTime());
+  timer4.deleteTimer();
+  std::cout << "final:   " << sol4.fitness() << std::endl<< std::endl;
+    
+}
+
+// A main that catches the exceptions
+	
+int main(int argc, char **argv)
+{
+  try{
+    main_function(argc, argv);
+  }
+  catch(exception& e){
+    cout << "Exception: " << e.what() << '\n';
+  }
+  return 1;
+}
+

ParadisEO-GPU/tutoriel/OneMax/testSimulatedAnnealing.cu

@@ -0,0 +1,230 @@
+///Init the number of threads per block
+#define BLOCK_SIZE 128
+
+//-----------------------------------------------------------------------------
+#include <iostream>  
+#include <stdlib.h> 
+using namespace std;
+
+// The general include for eo
+#include <eo>
+#include <ga.h>
+// Fitness function
+#include <problems/eval/EvalOneMax.h>
+// Cuda Fitness function
+#include <eval/moCudaVectorEval.h>
+#include <problems/eval/OneMaxIncrEval.h>
+// One Max solution
+#include <cudaType/moCudaBitVector.h>
+//To compute execution time
+#include <performance/moCudaTimer.h>
+// One Max neighbor
+#include <neighborhood/moCudaBitNeighbor.h>
+// One Max ordered neighborhood
+#include <neighborhood/moCudaRndWithReplNeighborhood.h>
+//Algorithm and its components
+#include <coolingSchedule/moCoolingSchedule.h>
+#include <algo/moSA.h>
+
+// The simulated annealing algorithm explorer
+#include <explorer/moSAexplorer.h>
+
+//comparator
+#include <comparator/moSolNeighborComparator.h>
+
+//continuators
+#include <continuator/moTrueContinuator.h>
+#include <continuator/moCheckpoint.h>
+#include <continuator/moFitnessStat.h>
+#include <utils/eoFileMonitor.h>
+#include <continuator/moCounterMonitorSaver.h>
+
+//-----------------------------------------------------------------------------
+// Define types of the representation solution, different neighbors and neighborhoods
+//-----------------------------------------------------------------------------
+// REPRESENTATION
+
+typedef moCudaBitVector<eoMaximizingFitness> solution;
+typedef moCudaBitNeighbor <solution,eoMaximizingFitness> Neighbor;
+typedef moCudaRndWithReplNeighborhood<Neighbor> Neighborhood;
+
+void main_function(int argc, char **argv)
+{
+	/* =========================================================
+*
+* Parameters
+*
+* ========================================================= */
+
+// First define a parser from the command-line arguments
+eoParser parser(argc, argv);
+
+// For each parameter, define Parameter, read it through the parser,
+// and assign the value to the variable
+
+eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+parser.processParam( seedParam );
+unsigned seed = seedParam.value();
+
+// description of genotype
+eoValueParam<unsigned int> vecSizeParam(8, "vecSize", "Genotype size", 'V');
+parser.processParam( vecSizeParam, "Representation" );
+unsigned vecSize = vecSizeParam.value();
+
+// the name of the "status" file where all actual parameter values will be saved
+string str_status = parser.ProgramName() + ".status"; // default value
+eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
+parser.processParam( statusParam, "Persistence" );
+
+// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
+// i.e. in case you need parameters somewhere else, postpone these
+if (parser.userNeedsHelp()) {
+	parser.printHelp(cout);
+	exit(1);
+}
+if (statusParam.value() != "") {
+	ofstream os(statusParam.value().c_str());
+	os << parser;// and you can use that file as parameter file
+}
+
+/* =========================================================
+ *
+ * Random seed
+ *
+ * ========================================================= */
+
+//reproducible random seed: if you don't change SEED above,
+// you'll always get the same result, NOT a random run
+rng.reseed(seed);
+
+/* =========================================================
+ *
+ * Initilisation of the solution
+ *
+ * ========================================================= */
+
+//solution sol(size);
+solution sol(vecSize);
+
+for(int i=0;i<vecSize;i++) cout<<sol[i]<<"  ";
+cout<<endl;
+
+/* =========================================================
+ *
+ * Eval fitness function
+ *
+ * ========================================================= */
+
+EvalOneMax<solution> eval;
+
+/* =========================================================
+ *
+ * Evaluation of a solution neighbor's
+ *
+ * ========================================================= */
+
+  OneMaxIncrEval<Neighbor> incr_eval;
+  moCudaVectorEval<Neighbor,OneMaxIncrEval<Neighbor> > cueval(vecSize,incr_eval);
+/* =========================================================
+ *
+ * Comparator of solutions and neighbors
+ *
+ * ========================================================= */
+
+ // moNeighborComparator<Neighbor> comparator;
+  moSolNeighborComparator<Neighbor> solComparator;
+
+/* =========================================================
+ *
+ * a solution neighborhood
+ *
+ * ========================================================= */
+
+  Neighborhood neighborhood(vecSize,cueval);
+/* =========================================================
+ *
+ * the cooling schedule of the process
+ *
+ * ========================================================= */
+
+
+// initial temp, factor of decrease, number of steps without decrease, final temp.
+  moSimpleCoolingSchedule<solution> coolingSchedule(500, 0.9, 1000, 0.01);
+
+/* =========================================================
+ *
+ * the local search algorithm
+ *
+ * ========================================================= */
+
+  moSA<Neighbor> localSearch1(neighborhood, eval, cueval,coolingSchedule);
+
+/* =========================================================
+ *
+ * execute the local search from random solution
+ *
+ * ========================================================= */
+
+//init(solution);
+eval(sol);
+
+std::cout << "#########################################" << std::endl;
+std::cout << "initial solution1: " << sol.fitness() << std::endl;
+
+localSearch1(sol);
+
+std::cout << "final solution1: " << sol.fitness() << std::endl;
+std::cout << "#########################################" << std::endl;
+
+
+/* =========================================================
+ *
+ * Comparator of neighbors
+ *
+ * ========================================================= */
+
+// moSolNeighborComparator<Neighbor> solComparator;
+
+/* =========================================================
+ *
+ * Example of Checkpointing
+ *
+ * ========================================================= */
+
+ /*moTrueContinuator<Neighbor> continuator;//always continue
+ moCheckpoint<Neighbor> checkpoint(continuator);
+ moFitnessStat<solution> fitStat;
+ checkpoint.add(fitStat);
+ eoFileMonitor monitor("fitness.out", "");
+ moCounterMonitorSaver countMon(100, monitor);
+ checkpoint.add(countMon);
+ monitor.add(fitStat);
+
+ moSA<Neighbor> localSearch2(neighborhood, eval, cueval, coolingSchedule, solComparator, checkpoint);
+
+ 
+ eval(sol1);
+ for(int i=0;i<vecSize;i++) cout<<sol1[i]<<"  ";
+ cout<<endl;
+
+ std::cout << "#########################################" << std::endl;
+ std::cout << "initial solution2: " << sol1.fitness() << std::endl ;
+
+ localSearch2(sol);
+
+ std::cout << "final solution2: " << sol1.fitness() << std::endl ;
+ std::cout << "#########################################" << std::endl;*/
+}
+
+// A main that catc hes the exceptions
+
+int main(int argc, char **argv)
+{
+	try {
+		main_function(argc, argv);
+	}
+	catch (exception& e) {
+		cout << "Exception: " << e.what() << '\n';
+	}
+	return 1;
+}