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

ParadisEO-GPU/tutoriel/Kswap-OneMax/testKswapHC.cu

@@ -1,5 +1,5 @@
 //Init the number of threads per block
-#define BLOCK_SIZE 512
+#define BLOCK_SIZE 256
 #include <iostream>  
 #include <stdlib.h> 
 using namespace std;
@@ -27,39 +27,8 @@ using namespace std;
 #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>
-#include <time.h>
-
-/**
- * @return the factorial of an unsigned integer
- * @param i an integer
- */
-
-unsigned long int factorial1(unsigned int i) {
-	if (i == 0)
-		return 1;
-	else
-		return i * factorial1(i - 1);
-}
-
-/**
- * @return the neighborhood Size from the solution size and number of swap
- * @param _size the solution size
- * @param _Kswap the number of swap
- */
-
-unsigned long int sizeMapping1( unsigned int _size, unsigned int _Kswap) {
-
-	unsigned long int _sizeMapping = _size;
-	for (unsigned int i = _Kswap; i > 0; i--) {
-		_sizeMapping *= (_size - i);
-	}
-	_sizeMapping /= factorial1(_Kswap + 1);
-	return _sizeMapping;
-}
 
 // REPRESENTATION
 typedef moCudaBitVector<eoMaximizingFitness> solution;
@@ -68,7 +37,6 @@ typedef moCudaKflipNeighborhood<Neighbor> Neighborhood;
 
 void main_function(int argc, char **argv)
 {
-
   /* =========================================================
    *
    * Parameters
@@ -91,7 +59,7 @@ void main_function(int argc, char **argv)
   parser.processParam( vecSizeParam, "Representation" );
   unsigned vecSize = vecSizeParam.value();
 
-// Swap number
+  // Swap number
   eoValueParam<unsigned int> KSwapParam(0, "KSwap", "swap number", 'N');
   parser.processParam(KSwapParam, "KSwap" );
   unsigned KSwap = KSwapParam.value();
@@ -120,7 +88,6 @@ void main_function(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);
-  srand(time(NULL));
   
   /* =========================================================
    *
@@ -129,9 +96,6 @@ void main_function(int argc, char **argv)
    * ========================================================= */
   
   solution sol(vecSize); 
-  if(vecSize<64)
-    for(unsigned i=0;i<vecSize;i++) cout<<sol[i]<<"  ";
-  cout<<endl;
 
   /* =========================================================
    *
@@ -146,7 +110,8 @@ void main_function(int argc, char **argv)
    * Evaluation of a solution neighbor's
    *
    * ========================================================= */
-  unsigned long int sizeMap=sizeMapping1(vecSize,KSwap);
+
+  unsigned long int sizeMap=sizeMapping(vecSize,KSwap);
   std::cout<<"sizeMap : "<<sizeMap<<std::endl;
   OneMaxIncrEval<Neighbor> incr_eval;
   moCudaKswapEval<Neighbor,OneMaxIncrEval<Neighbor> > cueval(sizeMap,incr_eval);
@@ -182,20 +147,11 @@ void main_function(int argc, char **argv)
    * 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
@@ -205,17 +161,15 @@ void main_function(int argc, char **argv)
   //Can be eval here, else it will be done at the beginning of the localSearch
   eval(sol);
 
-  std::cout << "initial: " << sol.fitness()<< std::endl;
+  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();
-  std::cout << "final:   " << sol.fitness() << std::endl;
-
-  
 }
 
 // A main that catches the exceptions