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
*/
#ifndef __EvalOneMax
#define __EvalOneMax
#ifndef __EvalOneMax_H
#define __EvalOneMax_H
/**
* 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
Contact: paradiseo-help@lists.gforge.inria.fr
*/
*/
#ifndef __OneMaxIncrEval_H
#define __OneMaxIncrEval_H
#include <eval/moCudaEvalFunc.h>
#include <eval/moGPUEvalFunc.h>
/**
* Incremental Evaluation of OneMax
*/
template<class Neighbor>
class OneMaxIncrEval: public moCudaEvalFunc<Neighbor> {
class OneMaxIncrEval: public moGPUEvalFunc<Neighbor> {
public:
public:
typedef typename Neighbor::EOT EOT;
typedef typename EOT::Fitness Fitness;
typedef typename EOT::ElemType T;
/**
* 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 _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;
if (_bitVector[_index[0]] == 0)
tmp= _fitness+1;
Fitness tmp=_fitness;
for(unsigned i=0;i<NB_POS;i++) {
if (_bitVector[_index[i]] == 0)
tmp= tmp+1;
else
tmp= _fitness-1;
return tmp;
tmp= tmp-1;
}
return tmp;
}
};
#endif

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

@ -30,17 +30,17 @@
ParadisEO WebSite : http://paradiseo.gforge.inria.fr
Contact: paradiseo-help@lists.gforge.inria.fr
*/
*/
#ifndef __PPPEval
#define __PPPEval
#ifndef __PPPEval_H
#define __PPPEval_H
#include <problems/data/PPPData.h>
template<class EOT, class ElemType = typename EOT::ElemType>
class PPPEval: public eoEvalFunc<EOT> {
class PPPEval: public eoEvalFunc<EOT> {
public:
public:
/**
* Constructor
@ -67,34 +67,34 @@ template<class EOT, class ElemType = typename EOT::ElemType>
int *H;
int *S;
int tmp_1=0;
int tmp_2=0;
int tmp_1 = 0;
int tmp_2 = 0;
H=new int[Nd+1];
S=new int[Md];
H = new int[Nd];
S = new int[Md];
for (int i=0; i<Md; i++){
S[i]=0;
for (int j=0; j<Nd; j++){
S[i]+=pppData.a_h[i*Nd+j]*_sol[j];
for (int i = 0; i < Md; i++) {
S[i] = 0;
for (int j = 0; j < Nd; j++) {
S[i] += pppData.a_h[i * Nd + j] * _sol[j];
}
tmp_1+=abs(S[i])-S[i];
if(S[i]>=0)
H[S[i]]++;
tmp_1 += abs(S[i]) - S[i];
if (S[i] > 0)
H[S[i]-1]++;
}
for (int j=0; j<=Nd; j++){
tmp_2+=abs(pppData.H_h[j]-H[j]);
for (int j = 0; j < Nd; 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[] S;
}
protected:
protected:
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
Contact: paradiseo-help@lists.gforge.inria.fr
*/
*/
#ifndef __PPPIncrEval_H
#define __PPPIncrEval_H
#include <eval/moCudaEvalFunc.h>
#include <eval/moGPUEvalFunc.h>
/**
* Incremental Evaluation of PPP
*/
template<class Neighbor>
class PPPIncrEval: public moCudaEvalFunc<Neighbor> {
class PPPIncrEval: public moGPUEvalFunc<Neighbor> {
public:
public:
typedef typename Neighbor::EOT EOT;
typedef typename EOT::Fitness Fitness;
typedef typename EOT::ElemType T;
/**
* 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)
* @param _sol the solution to evaluate
* Incremental evaluation of the PPP solution,function inline can be called from host or device
* @param _bitVector the solution to evaluate
* @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 tmp_1=0;
int tmp_2=0;
for (int i=0; i<Md; i++){
for (unsigned i=0; i<Md; i++) {
S[i]=0;
for (int j=0; j<Nd; j++){
if(_sol[j])
S[i]=S[i]+dev_a[i*Nd+j];
else
S[i]=S[i]-dev_a[i*Nd+j];
for (int j=0; j<Nd; j++)
S[i]+=dev_a[i*Nd+j]*_sol[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];
if(S[i]>=0)
H[S[i]]=H[S[i]]+1;
if(S[i]>0)
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]);
}
return ca*tmp_1+cb*tmp_2;
}
};
#endif

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

@ -30,17 +30,17 @@
ParadisEO WebSite : http://paradiseo.gforge.inria.fr
Contact: paradiseo-help@lists.gforge.inria.fr
*/
*/
#ifndef __QAPEval
#define __QAPEval
#ifndef __QAPEval_H
#define __QAPEval_H
#include <problems/data/QAPData.h>
template<class EOT, class ElemType = typename EOT::ElemType>
class QAPEval: public eoEvalFunc<EOT> {
class QAPEval: public eoEvalFunc<EOT> {
public:
public:
/**
* Constructor
@ -75,7 +75,7 @@ template<class EOT, class ElemType = typename EOT::ElemType>
_sol.fitness(cost);
}
protected:
protected:
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
Contact: paradiseo-help@lists.gforge.inria.fr
*/
*/
#ifndef __QAPIncrEval_H
#define __QAPIncrEval_H
#include <eval/moCudaEvalFunc.h>
#include <eval/moGPUEvalFunc.h>
/**
* Incremental Evaluation of QAP
*/
template<class Neighbor>
class QAPIncrEval: public moCudaEvalFunc<Neighbor> {
class QAPIncrEval: public moGPUEvalFunc<Neighbor> {
public:
public:
typedef typename Neighbor::EOT EOT;
typedef typename EOT::Fitness Fitness;
typedef typename EOT::ElemType T;
/**
* 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)
* @param _sol the solution to evaluate
* Incremental evaluation of the QAP solution,function inline can be called from host or device
* @param _bitVector the solution to evaluate
* @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) {
Fitness tmp;
inline __host__ __device__ Fitness operator() (T * _sol,Fitness _fitness, unsigned int *_index) {
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)
* _index[0] the first position of swap
* _index[1] the second position of swap
* _index[2] the solution size
* _index[3] the id of neighbor
* _index[i] the first position of swap
* _index[i+1] the second position of swap
*/
/* 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)
* @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 _sol the solution to evaluate
* @param _i the first position of swap
* @param _j the second position of swap
* @param _size the id of neighbor
* @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 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]]) +
(_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]]);
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]]);
for (k = 0; k < _size; k=k+1)
for (k = 0; k < SIZE; k=k+1)
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]]) +
(_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]]);
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]]);
return(d);
}
}
};