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

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

@ -35,19 +35,20 @@
#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

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

@ -32,8 +32,8 @@
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>
@ -70,7 +70,7 @@ template<class EOT, class ElemType = typename EOT::ElemType>
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++) {
@ -80,11 +80,11 @@ template<class EOT, class ElemType = typename EOT::ElemType>
} }
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]);
} }

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

@ -35,19 +35,20 @@
#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

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

@ -32,8 +32,8 @@
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>

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

@ -35,19 +35,20 @@
#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,26 +65,30 @@ 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[0],_index[1],_index[2],_index[3]); //tmp=_fitness+compute_delta(dev_a,dev_b,_sol,_index[i],_index[i+1],id);
return tmp; 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]];
} }
@ -94,24 +99,22 @@ class QAPIncrEval: public moCudaEvalFunc<Neighbor> {
* @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);
} }