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

ParadisEO-GPU/tutoriel/QAP_CPU/application/CMakeLists.txt

@@ -41,9 +41,11 @@ LINK_DIRECTORIES(${PARADISEO_EO_BIN_DIR}/lib  ${NVIDIA_LIB_DIR} ${CUDA_LIB_DIR}
 ### 3) Define your targets and link the librairies
 ######################################################################################	
 			
-CUDA_ADD_EXECUTABLE(CutestSimpleTS_CPU testSimpleTS_CPU.cu) 
+CUDA_ADD_EXECUTABLE(CutestSimpleTS_CPU testSimpleTS_CPU.cu) 			
+#CUDA_ADD_EXECUTABLE(CutestSimpleHC_CPU testSimpleHC_CPU.cu)
 
 TARGET_LINK_LIBRARIES(CutestSimpleTS_CPU eoutils ga eo libcutil.a)
+#TARGET_LINK_LIBRARIES(CutestSimpleHC_CPU eoutils ga eo libcutil.a)
 
 
 

ParadisEO-GPU/tutoriel/QAP_CPU/application/testSimpleHC_CPU.cu

@@ -0,0 +1,189 @@
+#include <iostream>
+#include <stdlib.h>
+#include <stdio.h>
+using namespace std;
+
+int * a;
+int * b;
+int n;
+
+// The general include for eo
+#include <eo>
+#include <ga.h>
+// Fitness function
+#include <QapEval.h>
+// Cuda Fitness function
+#include <QapIncrEval.h>
+// QAP solution
+#include <eoVector.h>
+#include <eoInt.h>
+//To compute execution time
+#include <performance/moCudaTimer.h>
+//QAP neighbor
+#include <problems/permutation/moSwapNeighbor.h>
+//QAP neighborhood 
+#include <problems/permutation/moSwapNeighborhood.h>
+//QAP data
+#include <Problem.h>
+// The Solution and neighbor comparator
+#include <comparator/moNeighborComparator.h>
+#include <comparator/moSolNeighborComparator.h>
+// The Iter continuator
+#include <continuator/moIterContinuator.h>
+// Local search algorithm
+#include <algo/moLocalSearch.h>
+// The Tabou Search algorithm explorer
+#include <explorer/moSimpleHCexplorer.h>
+
+
+typedef eoInt<eoMinimizingFitness> solution;
+typedef moSwapNeighbor<solution> Neighbor;
+typedef moSwapNeighborhood<solution> Neighborhood;
+
+
+int main(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();
+
+  // Iteration number
+  eoValueParam<unsigned int> nbIterationParam(1, "nbIteration", "TS Iteration number", 'I');
+  parser.processParam( nbIterationParam, "TS Iteration number" );
+  unsigned nbIteration = nbIterationParam.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);
+  //srand(seed);
+  
+  /* =========================================================
+   *
+   * Initilisation of QAP data
+   *
+   * ========================================================= */
+
+   load(argv[1]);
+
+  /* =========================================================
+   *
+   * Initilisation of the solution
+   *
+   * ========================================================= */
+
+   solution sol(n);
+   create<solution>(sol);
+
+ /* =========================================================
+   *
+   * Evaluation of a solution neighbor's
+   *
+   * ========================================================= */
+
+  QapEval<solution> eval;
+  QapIncrEval<Neighbor> incr_eval;
+
+  /* =========================================================
+   *
+   * Comparator of solutions and neighbors
+   *
+   * ========================================================= */
+
+  moNeighborComparator<Neighbor> comparator;
+  moSolNeighborComparator<Neighbor> solComparator;
+
+  /* =========================================================
+   *
+   * a solution neighborhood
+   *
+   * ========================================================= */
+ 
+  Neighborhood neighborhood;
+
+  /* =========================================================
+   *
+   * continuator
+   *
+   * ========================================================= */
+
+   moIterContinuator <Neighbor> continuator(nbIteration);
+
+  /* =========================================================
+   *
+   * An explorer of solution neighborhood's
+   *
+   * ========================================================= */
+
+  moSimpleHCexplorer<Neighbor> explorer(neighborhood, incr_eval, comparator, solComparator);
+
+  
+  /* =========================================================
+   *
+   * the local search algorithm
+   *
+   * ========================================================= */
+
+  moLocalSearch<Neighbor> localSearch(explorer, continuator, eval);
+
+  /* =========================================================
+   *
+   * 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<< std::endl;
+ // Create timer for timing CUDA calculation
+  moCudaTimer timer;
+  timer.start();
+  localSearch(sol);
+  timer.stop();
+  std::cout << "final:   " << sol << std::endl;
+  printf("CUDA execution time = %f ms\n",timer.getTime());
+  timer.deleteTimer();
+ 
+  delete[] a;
+  delete[] b;    
+
+
+return 0;
+}
+

ParadisEO-GPU/tutoriel/QAP_CPU/application/testSimpleTS_CPU.cu

@@ -3,8 +3,8 @@
 #include <stdio.h>
 using namespace std;
 
-int ** a;
+int * a;
-int ** b;
+int * b;
 int n;
 
 // The general include for eo
@@ -20,9 +20,12 @@ int n;
 //To compute execution time
 #include <performance/moCudaTimer.h>
 //QAP neighbor
-#include <problems/permutation/moSwapNeighbor.h>
+#include <problems/permutation/moIndexedSwapNeighbor.h>
 //QAP neighborhood 
-#include <problems/permutation/moSwapNeighborhood.h>
+//#include <problems/permutation/moSwapNeighborhood.h>
+#include <neighborhood/moOrderNeighborhood.h>
+//QAP data
+#include <Problem.h>
 // The Solution and neighbor comparator
 #include <comparator/moNeighborComparator.h>
 #include <comparator/moSolNeighborComparator.h>
@@ -31,23 +34,25 @@ int n;
 // Local search algorithm
 #include <algo/moLocalSearch.h>
 // The Tabou Search algorithm explorer
-#include <explorer/moTSexplorer.h>
+//#include <explorer/moTSexplorer.h>
 //Algorithm and its components
 #include <algo/moTS.h>
 //Tabu list
-#include <memory/moNeighborVectorTabuList.h>
+//#include <memory/moNeighborVectorTabuList.h>
+#include <memory/moIndexedVectorTabuList.h>
 //Memories
 #include <memory/moDummyIntensification.h>
 #include <memory/moDummyDiversification.h>
 #include <memory/moBestImprAspiration.h>
-#include <time.h>
+//#include <time.h>
-#include <Problem.h>
+
 
 
 typedef eoInt<eoMinimizingFitness> solution;
-typedef moSwapNeighbor<solution> Neighbor;
+//typedef moSwapNeighbor<solution> Neighbor;
-typedef moSwapNeighborhood<solution> Neighborhood;
+typedef moIndexedSwapNeighbor<solution> Neighbor;
-
+//typedef moSwapNeighborhood<solution> Neighborhood;
+typedef moOrderNeighborhood<Neighbor> Neighborhood;
 
 int main(int argc, char **argv)
 {
@@ -69,11 +74,6 @@ int main(int argc, char **argv)
   parser.processParam( seedParam );
   unsigned seed = seedParam.value();
 
- // Swap number
-  eoValueParam<unsigned int> KSwapParam(1, "KSwap", "swap number", 'N');
-  parser.processParam(KSwapParam, "KSwap" );
-  unsigned KSwap = KSwapParam.value();
-
   // Iteration number
   eoValueParam<unsigned int> nbIterationParam(1, "nbIteration", "TS Iteration number", 'I');
   parser.processParam( nbIterationParam, "TS Iteration number" );
@@ -113,7 +113,7 @@ int main(int argc, char **argv)
 
   //reproducible random seed: if you don't change SEED above,
   // you'll aways get the same result, NOT a random run
-  rng.reseed(seed);
+//  rng.reseed(seed);
   srand(seed);
   
   /* =========================================================
@@ -121,59 +121,62 @@ int main(int argc, char **argv)
    * Initilisation of QAP data
    *
    * ========================================================= */
+
    load(argv[1]);
+
   /* =========================================================
    *
    * Initilisation of the solution
    *
    * ========================================================= */
- 
+
    solution sol(n);
    create<solution>(sol);
- /* =========================================================
+
+  /*=========================================================
    *
    * Evaluation of a solution neighbor's
    *
    * ========================================================= */
- 
+
-  QapEval<solution> eval;
+   QapEval<solution> eval;
-  QapIncrEval<Neighbor> incr_eval;
+   QapIncrEval<Neighbor> incr_eval;
-  
+
   /* =========================================================
    *
    * Comparator of solutions and neighbors
    *
    * ========================================================= */
 
-  moNeighborComparator<Neighbor> comparator;
+      moNeighborComparator<Neighbor> comparator;
-  moSolNeighborComparator<Neighbor> solComparator;
+      moSolNeighborComparator<Neighbor> solComparator;
 
   /* =========================================================
    *
    * a solution neighborhood
    *
    * ========================================================= */
-
-   Neighborhood neighborhood;
  
- /* =========================================================
+      Neighborhood neighborhood(n*(n-1)/2);
+
+  /* =========================================================
    *
    * continuator
    *
    * ========================================================= */
 
-   moIterContinuator <Neighbor> continuator(nbIteration);
+     moIterContinuator <Neighbor> continuator(nbIteration);
 
- /* =========================================================
+  /*=========================================================
    *
-   * tabu list
+   * Tabu list
    *
    * ========================================================= */
 
-  sizeTabuList=(n*(n-1))/4;
+    sizeTabuList=(n*(n-1))/2;
-  duration=sizeTabuList/8;
+    duration=sizeTabuList/8;
-  // tabu list
+    // tabu list
-  moNeighborVectorTabuList<Neighbor> tl(sizeTabuList,duration);
+    moIndexedVectorTabuList<Neighbor> tl(sizeTabuList,duration);
 
   /* =========================================================
    *
@@ -181,29 +184,22 @@ int main(int argc, char **argv)
    *
    * ========================================================= */
 
-  moDummyIntensification<Neighbor> inten;
+    moDummyIntensification<Neighbor> inten;
-  moDummyDiversification<Neighbor> div;
+    moDummyDiversification<Neighbor> div;
-  moBestImprAspiration<Neighbor> asp;
+    moBestImprAspiration<Neighbor> asp;
 
   /* =========================================================
    *
-   * An explorer of solution neighborhood's
+   * the Tabu search algorithm  
    *
    * ========================================================= */
 
-  moTSexplorer<Neighbor> explorer(neighborhood, incr_eval, comparator, solComparator, tl, inten, div, asp);
+    //General Constructor
+    moTS<Neighbor> tabuSearch(neighborhood, eval, incr_eval, comparator, solComparator, continuator, tl, inten, div, asp);  
 
-  
   /* =========================================================
    *
-   * the local search algorithm
+   * Execute the Tabu search from random sollution
-   *
-   * ========================================================= */
-
-  moLocalSearch<Neighbor> localSearch(explorer, continuator, eval);
-  /* =========================================================
-   *
-   * Execute the local search from random sollution
    *
    * ========================================================= */
  
@@ -214,20 +210,15 @@ int main(int argc, char **argv)
  // Create timer for timing CUDA calculation
   moCudaTimer timer;
   timer.start();
-  localSearch(sol);
+  tabuSearch(sol);
   timer.stop();
   std::cout << "final:   " << sol << std::endl;
   printf("CUDA execution time = %f ms\n",timer.getTime());
   timer.deleteTimer();
  
- for(int i=0 ; i <n ; i++)
+  delete[] a;
-      delete[] a[i];
+  delete[] b;    
-    delete[] a;
-    for(int i=0 ; i <n ; i++)
-      delete[] b[i];
-    delete[] b;    
 
 
 return 0;
 }
-

ParadisEO-GPU/tutoriel/QAP_CPU/src/Problem.h

@@ -8,18 +8,14 @@ void load(char* _fileName){
       fscanf(f,"%d",&n);
     else 
       printf("Le Fichier est vide\n");
-   a=new int*[n];
+   a=new int[n*n];
-    for(int i=0;i<n;i++)
+   b=new int[n*n];
-      a[i]=new int[n];
-    b=new int*[n];
-    for(int i=0;i<n;i++)
-      b[i]=new int[n];
     for (i=0;i<n;i++)
       for(j=0;j<n;j++)
-	fscanf(f,"%d",&a[i][j]);      
+	fscanf(f,"%d",&a[i*n+j]);      
     for (i=0;i<n;i++)
       for(j=0;j<n;j++)
-	fscanf(f,"%d",&b[i][j]);
+	fscanf(f,"%d",&b[i*n+j]);
   }
 
 template<class EOT>

ParadisEO-GPU/tutoriel/QAP_CPU/src/QapEval.h

@@ -13,12 +13,9 @@ class QapEval : public eoEvalFunc<EOT>
 
   void operator() (EOT & _sol) {
     int cost=0;
-    for (int i=0; i<n; i++)
-      std::cout<<_sol[i]<<" ";
-    std::cout<<std::endl;
     for (int i=0; i<n; i++)
       for (int j=0; j<n; j++)
-	cost += a[i][j] * b[_sol[i]][_sol[j]]; 
+	cost += a[i*n+j] * b[_sol[i]*n+_sol[j]]; 
     _sol.fitness(cost);
   }
     

ParadisEO-GPU/tutoriel/QAP_CPU/src/QapIncrEval.h

@@ -21,23 +21,24 @@ class QapIncrEval : public moEval<Neighbor>{
 
     int cost=0;
     unsigned i,j;
-    int neighborhoodsize = (n * (n - 1)) / 2;
+   _neighbor.getIndices(n,i,j);
-   _neighbor.getIndices(i,j);
     cost = _sol.fitness() +compute_delta(n,a,b,_sol,i,j);
     _neighbor.fitness(cost);
   }
 
   // specific to the QAP incremental evaluation (part of algorithmic)
-  int compute_delta(int n, int** a, int** b,EOT & _sol,int i,int j)
+  int compute_delta(int n, int* a, int* b,EOT & _sol,int i,int j)
   {
     int d; int k;
-    d = (a[i][i]-a[j][j])*(b[_sol[j]][_sol[j]]-b[_sol[i]][_sol[i]]) +
+    d = (a[i*n+i]-a[j*n+j])*(b[_sol[j]*n+_sol[j]]-b[_sol[i]*n+_sol[i]]) +
-      (a[i][j]-a[j][i])*(b[_sol[j]][_sol[i]]-b[_sol[i]][_sol[j]]);
+      (a[i*n+j]-a[j*n+i])*(b[_sol[j]*n+_sol[i]]-b[_sol[i]*n+_sol[j]]);
     for (k = 0; k < n; k = k + 1) 
       if (k!=i && k!=j)
-	d = d + (a[k][i]-a[k][j])*(b[_sol[k]][_sol[j]]-b[_sol[k]][_sol[i]]) +
+	d = d + (a[k*n+i]-a[k*n+j])*(b[_sol[k]*n+_sol[j]]-b[_sol[k]*n+_sol[i]]) +
-	  (a[i][k]-a[j][k])*(b[_sol[j]][_sol[k]]-b[_sol[i]][_sol[k]]);
+	  (a[i*n+k]-a[j*n+k])*(b[_sol[j]*n+_sol[k]]-b[_sol[i]*n+_sol[k]]);
     return(d);
   }
+
+
 }; 
 #endif

ParadisEO-GPU/tutoriel/QAP_CPU/src/Solution.h

@@ -1,9 +1,9 @@
 #ifndef _SOLUTION_H_
 #define _SOLUTION_H_
 
-#include <eo> // PARADISEO
+#include <eo>
 
-class Solution:public EO <eoMinimizingFitness>{ // PARADISEO
+class Solution:public EO <eoMinimizingFitness>{ 
 
  public: