nojhan/paradiseo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

update problems evaluation

Browse source 
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@2265 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
boufaras 2011-05-25 21:47:06 +00:00
commit b0e9ea0bb5
6 changed files with 406 additions and 398 deletions
Download patch file Download diff file Expand all files Collapse all files

4
branches/ParadisEO-GPU/src/problems/eval/EvalOneMax.h
View file

@ -32,8 +32,8 @@
Contact: paradiseo-help@lists.gforge.inria.fr Contact: paradiseo-help@lists.gforge.inria.fr
*/ */
#ifndef __EvalOneMax #ifndef __EvalOneMax_H
#define __EvalOneMax #define __EvalOneMax_H
/** /**
* Full Evaluation of the solution * Full Evaluation of the solution

33
branches/ParadisEO-GPU/src/problems/eval/OneMaxIncrEval.h
View file

@ -30,24 +30,25 @@
ParadisEO WebSite : http://paradiseo.gforge.inria.fr ParadisEO WebSite : http://paradiseo.gforge.inria.fr
Contact: paradiseo-help@lists.gforge.inria.fr Contact: paradiseo-help@lists.gforge.inria.fr
*/ */
#ifndef __OneMaxIncrEval_H #ifndef __OneMaxIncrEval_H
#define __OneMaxIncrEval_H #define __OneMaxIncrEval_H
#include <eval/moCudaEvalFunc.h> #include <eval/moGPUEvalFunc.h>
/** /**
* Incremental Evaluation of OneMax * Incremental Evaluation of OneMax
*/ */
template<class Neighbor> template<class Neighbor>
class OneMaxIncrEval: public moCudaEvalFunc<Neighbor> { class OneMaxIncrEval: public moGPUEvalFunc<Neighbor> {
public: public:
typedef typename Neighbor::EOT EOT; typedef typename Neighbor::EOT EOT;
typedef typename EOT::Fitness Fitness; typedef typename EOT::Fitness Fitness;
typedef typename EOT::ElemType T;
/** /**
* Constructor * Constructor
@ -64,27 +65,27 @@ class OneMaxIncrEval: public moCudaEvalFunc<Neighbor> {
} }
/** /**
* Incremental evaluation of the solution(function inline can be called from host or device) * Incremental evaluation of the OneMax solution(bit vector),function inline can be called from host or device
* @param _bitVector the solution to evaluate * @param _bitVector the solution to evaluate
* @param _fitness the fitness of the current solution * @param _fitness the fitness of the current solution
* @param _index the index of solution neighbor * @param _index an array that contains a set of indexes corresponding to the current thread identifier neighbor the last element of this array contains neighborhood size
*/ */
inline __host__ __device__ Fitness operator() (EOT & _bitVector,Fitness _fitness, unsigned int * _index) { inline __host__ __device__ Fitness operator() (T * _bitVector,Fitness _fitness, unsigned int * _index) {
Fitness tmp; Fitness tmp=_fitness;
for(unsigned i=0;i<NB_POS;i++) {
if (_bitVector[_index[0]] == 0)
tmp= _fitness+1;
if (_bitVector[_index[i]] == 0)
tmp= tmp+1;
else else
tmp= tmp-1;
tmp= _fitness-1;
return tmp;
} }
return tmp;
}
}; };
#endif #endif

40
branches/ParadisEO-GPU/src/problems/eval/PPPEval.h
View file

@ -30,17 +30,17 @@
ParadisEO WebSite : http://paradiseo.gforge.inria.fr ParadisEO WebSite : http://paradiseo.gforge.inria.fr
Contact: paradiseo-help@lists.gforge.inria.fr Contact: paradiseo-help@lists.gforge.inria.fr
*/ */
#ifndef __PPPEval #ifndef __PPPEval_H
#define __PPPEval #define __PPPEval_H
#include <problems/data/PPPData.h> #include <problems/data/PPPData.h>
template<class EOT, class ElemType = typename EOT::ElemType> template<class EOT, class ElemType = typename EOT::ElemType>
class PPPEval: public eoEvalFunc<EOT> { class PPPEval: public eoEvalFunc<EOT> {
public: public:
/** /**
* Constructor * Constructor
@ -67,34 +67,34 @@ template<class EOT, class ElemType = typename EOT::ElemType>
int *H; int *H;
int *S; int *S;
int tmp_1=0; int tmp_1 = 0;
int tmp_2=0; int tmp_2 = 0;
H=new int[Nd+1]; H = new int[Nd];
S=new int[Md]; S = new int[Md];
for (int i=0; i<Md; i++){ for (int i = 0; i < Md; i++) {
S[i]=0; S[i] = 0;
for (int j=0; j<Nd; j++){ for (int j = 0; j < Nd; j++) {
S[i]+=pppData.a_h[i*Nd+j]*_sol[j]; S[i] += pppData.a_h[i * Nd + j] * _sol[j];
} }
tmp_1+=abs(S[i])-S[i]; tmp_1 += abs(S[i]) - S[i];
if(S[i]>=0) if (S[i] > 0)
H[S[i]]++; H[S[i]-1]++;
} }
for (int j=0; j<=Nd; j++){ for (int j = 0; j < Nd; j++) {
tmp_2+=abs(pppData.H_h[j]-H[j]); tmp_2 += abs(pppData.H_h[j] - H[j]);
} }
_sol.fitness(ca*tmp_1+cb*tmp_2); _sol.fitness(ca * tmp_1 + cb * tmp_2);
delete[] H; delete[] H;
delete[] S; delete[] S;
} }
protected: protected:
PPPData<ElemType> pppData; PPPData<ElemType> pppData;

42
branches/ParadisEO-GPU/src/problems/eval/PPPIncrEval.h
View file

@ -30,24 +30,25 @@
ParadisEO WebSite : http://paradiseo.gforge.inria.fr ParadisEO WebSite : http://paradiseo.gforge.inria.fr
Contact: paradiseo-help@lists.gforge.inria.fr Contact: paradiseo-help@lists.gforge.inria.fr
*/ */
#ifndef __PPPIncrEval_H #ifndef __PPPIncrEval_H
#define __PPPIncrEval_H #define __PPPIncrEval_H
#include <eval/moCudaEvalFunc.h> #include <eval/moGPUEvalFunc.h>
/** /**
* Incremental Evaluation of PPP * Incremental Evaluation of PPP
*/ */
template<class Neighbor> template<class Neighbor>
class PPPIncrEval: public moCudaEvalFunc<Neighbor> { class PPPIncrEval: public moGPUEvalFunc<Neighbor> {
public: public:
typedef typename Neighbor::EOT EOT; typedef typename Neighbor::EOT EOT;
typedef typename EOT::Fitness Fitness; typedef typename EOT::Fitness Fitness;
typedef typename EOT::ElemType T;
/** /**
* Constructor * Constructor
@ -64,41 +65,44 @@ class PPPIncrEval: public moCudaEvalFunc<Neighbor> {
} }
/** /**
* functor of incremental evaluation of the solution(function inline can be called from host or device) * Incremental evaluation of the PPP solution,function inline can be called from host or device
* @param _sol the solution to evaluate * @param _bitVector the solution to evaluate
* @param _fitness the fitness of the current solution * @param _fitness the fitness of the current solution
* @param _index the set of information to compute fitness neighbor * @param _index an array that contains a set of indexes corresponding to the current thread identifier neighbor the last element of this array contains neighborhood size
*/ */
inline __host__ __device__ Fitness operator() (EOT & _sol,Fitness _fitness, unsigned int *_index) { inline __host__ __device__ Fitness operator() (T* _sol,Fitness _fitness, unsigned int *_index) {
int H[Nd+1]; int H[Nd];
int S[Md]; int S[Md];
int tmp_1=0; int tmp_1=0;
int tmp_2=0; int tmp_2=0;
for (int i=0; i<Md; i++){ for (unsigned i=0; i<Md; i++) {
S[i]=0; S[i]=0;
for (int j=0; j<Nd; j++){ for (int j=0; j<Nd; j++)
if(_sol[j]) S[i]+=dev_a[i*Nd+j]*_sol[j];
S[i]=S[i]+dev_a[i*Nd+j];
else
S[i]=S[i]-dev_a[i*Nd+j];
} }
for (unsigned j=0; j<Nd; j++)
H[j]=0;
for (unsigned i=0; i<Md; i++) {
for(unsigned k=0;k<NB_POS;k++)
S[i]=S[i]-2*dev_a[i*Nd+_index[k]]*_sol[_index[k]];
tmp_1=tmp_1+abs(S[i])-S[i]; tmp_1=tmp_1+abs(S[i])-S[i];
if(S[i]>=0) if(S[i]>0)
H[S[i]]=H[S[i]]+1; H[S[i]-1]=H[S[i]-1]+1;
} }
for (int j=0; j<=Nd; j++){ for (unsigned j=0; j<Nd; j++)
tmp_2=tmp_2+abs(dev_h[j]-H[j]); tmp_2=tmp_2+abs(dev_h[j]-H[j]);
}
return ca*tmp_1+cb*tmp_2; return ca*tmp_1+cb*tmp_2;
} }
}; };
#endif #endif

12
branches/ParadisEO-GPU/src/problems/eval/QAPEval.h
View file

@ -30,17 +30,17 @@
ParadisEO WebSite : http://paradiseo.gforge.inria.fr ParadisEO WebSite : http://paradiseo.gforge.inria.fr
Contact: paradiseo-help@lists.gforge.inria.fr Contact: paradiseo-help@lists.gforge.inria.fr
*/ */
#ifndef __QAPEval #ifndef __QAPEval_H
#define __QAPEval #define __QAPEval_H
#include <problems/data/QAPData.h> #include <problems/data/QAPData.h>
template<class EOT, class ElemType = typename EOT::ElemType> template<class EOT, class ElemType = typename EOT::ElemType>
class QAPEval: public eoEvalFunc<EOT> { class QAPEval: public eoEvalFunc<EOT> {
public: public:
/** /**
* Constructor * Constructor
@ -75,7 +75,7 @@ template<class EOT, class ElemType = typename EOT::ElemType>
_sol.fitness(cost); _sol.fitness(cost);
} }
protected: protected:
QAPData<ElemType> qapData; QAPData<ElemType> qapData;

59
branches/ParadisEO-GPU/src/problems/eval/QAPIncrEval.h
View file

@ -30,24 +30,25 @@
ParadisEO WebSite : http://paradiseo.gforge.inria.fr ParadisEO WebSite : http://paradiseo.gforge.inria.fr
Contact: paradiseo-help@lists.gforge.inria.fr Contact: paradiseo-help@lists.gforge.inria.fr
*/ */
#ifndef __QAPIncrEval_H #ifndef __QAPIncrEval_H
#define __QAPIncrEval_H #define __QAPIncrEval_H
#include <eval/moCudaEvalFunc.h> #include <eval/moGPUEvalFunc.h>
/** /**
* Incremental Evaluation of QAP * Incremental Evaluation of QAP
*/ */
template<class Neighbor> template<class Neighbor>
class QAPIncrEval: public moCudaEvalFunc<Neighbor> { class QAPIncrEval: public moGPUEvalFunc<Neighbor> {
public: public:
typedef typename Neighbor::EOT EOT; typedef typename Neighbor::EOT EOT;
typedef typename EOT::Fitness Fitness; typedef typename EOT::Fitness Fitness;
typedef typename EOT::ElemType T;
/** /**
* Constructor * Constructor
@ -64,57 +65,59 @@ class QAPIncrEval: public moCudaEvalFunc<Neighbor> {
} }
/** /**
* functor of incremental evaluation of the solution(function inline can be called from host or device) * Incremental evaluation of the QAP solution,function inline can be called from host or device
* @param _sol the solution to evaluate * @param _bitVector the solution to evaluate
* @param _fitness the fitness of the current solution * @param _fitness the fitness of the current solution
* @param _index the set of information to compute fitness neighbor * @param _index an array that contains a set of indexes corresponding to the current thread identifier neighbor the last element of this array contains neighborhood size
*/ */
inline __host__ __device__ Fitness operator() (EOT & _sol,Fitness _fitness, unsigned int *_index) { inline __host__ __device__ Fitness operator() (T * _sol,Fitness _fitness, unsigned int *_index) {
Fitness tmp;
Fitness tmp=_fitness;
//int id = blockIdx.x * blockDim.x + threadIdx.x;
T tmp_sol[1];
/** /**
* dev_a & dev_b are global device variable, data specific to QAP problem (flow & distance matices) * dev_a & dev_b are global device variable, data specific to QAP problem (flow & distance matices)
* _index[0] the first position of swap * _index[i] the first position of swap
* _index[1] the second position of swap * _index[i+1] the second position of swap
* _index[2] the solution size
* _index[3] the id of neighbor
*/ */
/* for(unsigned i=0;i<NB_POS;i++) {
//tmp=_fitness+compute_delta(dev_a,dev_b,_sol,_index[i],_index[i+1],id);
tmp=tmp+compute_delta(dev_a,dev_b,_sol,_index[i],_index[i+1],_index[NB_POS+1]);
tmp_sol[0]=_sol[_index[i]];
_sol[_index[i]]=_sol[_index[i+1]];
_sol[_index[i+1]]=tmp_sol[0];
}*/
return dev_b[_index[NB_POS+1]];
tmp=_fitness+compute_delta(dev_a,dev_b,_sol,_index[0],_index[1],_index[2],_index[3]); }
return tmp;
} /**
/**
* compute the new fitness of the solution after permutation of pair(i,j)(function inline called from host device) * compute the new fitness of the solution after permutation of pair(i,j)(function inline called from host device)
* @param _a the flow matrix of size*size (specific data of QAP problem must be declared as global device variable) * @param _a the flow matrix of size*size (specific data of QAP problem must be declared as global device variable)
* @param _b the distance matrix of size*size (specific data of QAP problem must be declared as global device variable) * @param _b the distance matrix of size*size (specific data of QAP problem must be declared as global device variable)
* @param _sol the solution to evaluate * @param _sol the solution to evaluate
* @param _i the first position of swap * @param _i the first position of swap
* @param _j the second position of swap * @param _j the second position of swap
* @param _size the id of neighbor
* @param _id the neighbor identifier * @param _id the neighbor identifier
*/ */
inline __host__ __device__ int compute_delta(int * _a,int * _b,EOT & _sol, int _i, int _j,int _size, int _id){ inline __host__ __device__ int compute_delta(int * _a,int * _b,T * _sol, int _i, int _j,int _id) {
int d; int d;
int k; int k;
d = (_a[_i*_size+_i]-_a[_j*_size+_j])*(_b[_sol[_j+_id*_size]*_size+_sol[_j+_id*_size]]-_b[_sol[_i+_id*_size]*_size+_sol[_i+_id*_size]]) + d = (_a[_i*SIZE+_i]-_a[_j*SIZE+_j])*(_b[_sol[_j+_id*SIZE]*SIZE+_sol[_j+_id*SIZE]]-_b[_sol[_i+_id*SIZE]*SIZE+_sol[_i+_id*SIZE]]) +
(_a[_i*_size+_j]-_a[_j*_size+_i])*(_b[_sol[_j+_id*_size]*_size+_sol[_i+_id*_size]]-_b[_sol[_i+_id*_size]*_size+_sol[_j+_id*_size]]); (_a[_i*SIZE+_j]-_a[_j*SIZE+_i])*(_b[_sol[_j+_id*SIZE]*SIZE+_sol[_i+_id*SIZE]]-_b[_sol[_i+_id*SIZE]*SIZE+_sol[_j+_id*SIZE]]);
for (k = 0; k < SIZE; k=k+1)
for (k = 0; k < _size; k=k+1)
if (k!=_i && k!=_j) if (k!=_i && k!=_j)
d = d + (_a[k*_size+_i]-_a[k*_size+_j])*(_b[_sol[k+_id*_size]*_size+_sol[_j+_id*_size]]-_b[_sol[k+_id*_size]*_size+_sol[_i+_id*_size]]) + d = d + (_a[k*SIZE+_i]-_a[k*SIZE+_j])*(_b[_sol[k+_id*SIZE]*SIZE+_sol[_j+_id*SIZE]]-_b[_sol[k+_id*SIZE]*SIZE+_sol[_i+_id*SIZE]]) +
(_a[_i*_size+k]-_a[_j*_size+k])*(_b[_sol[_j+_id*_size]*_size+_sol[k+_id*_size]]-_b[_sol[_i+_id*_size]*_size+_sol[k+_id*_size]]); (_a[_i*SIZE+k]-_a[_j*SIZE+k])*(_b[_sol[_j+_id*SIZE]*SIZE+_sol[k+_id*SIZE]]-_b[_sol[_i+_id*SIZE]*SIZE+_sol[k+_id*SIZE]]);
return(d); return(d);
} }
}; };