SolversThreads/SolversThreads.cpp

   1 /*
   2  *  SolverThreads.cpp
   3  *  PaGMO
   4  *
   5  *  Created by Dario Izzo on 9/21/08.
   6  *  Copyright 2008 __MyCompanyName__. All rights reserved.
   7  *
   8  */
   9
  10 #include <boost/thread/locks.hpp>
  11 #include <boost/thread/mutex.hpp>
  12 #include <fstream>
  13 #include <vector>
  14
  15 #include "ASA.h"
  16 #include "DE.h"
  17 #include "MPSO.h"
  18 #include "PSO.h"
  19 #include "SGA.h"
  20 #include "SolversThreads.h"
  21 #include "population.h"
  22 #include "rng.h"
  23
  24 using namespace std;
  25
  26 // Shortcut definition for the lock type.
  27 typedef boost::unique_lock<boost::mutex> lock_type;
  28
  29 //******************************************************************************************
  30 //DE thread type
  31 //******************************************************************************************
  32
  33 void *DEthread(void *data)
  34 {
  35    threadParam *PtrTP = (threadParam *)data;
  36    Population deme;
  37    double oldfitness;
  38    vector <int> picks;
  39    GOProblem* problem;
  40    vector<double> LB,UB;
  41    DEalgorithm DE;
  42    rng_uint32_type rng;
  43    rng_double_type drng;
  44
  45
  46         clock_t start,end;
  47         double dif;
  48
  49     {
  50         lock_type lock(*PtrTP->TPmutex);
  51         rng.seed(PtrTP->randomSeed);
  52         drng.seed(PtrTP->randomSeed);
  53                 deme = PtrTP->Ptr_pop->extractRandomDeme(PtrTP->NP,picks, drng);
  54                 problem = PtrTP->problem;
  55                 problem->getBounds(LB, UB);
  56                 DE.initDE(PtrTP->generations,LB.size(),PtrTP->F,PtrTP->CR,PtrTP->strategy, rng());
  57     }
  58
  59     oldfitness = deme.extractBestIndividual().getFitness();
  60
  61     start=clock();
  62    deme = DE.evolve(deme, *problem);
  63    end=clock();
  64    dif = (double)(end-start) / (double)CLOCKS_PER_SEC;
  65
  66    {
  67         lock_type lock(*PtrTP->TPmutex);
  68         //insert deme in main population
  69                 PtrTP->Ptr_pop->insertDeme(deme,picks);
  70                 //log in cout
  71                 cout << "Thread ID: " <<  PtrTP->threadID << endl ;
  72                 cout << "\t\t\tDE:\t\t\t F "<< PtrTP->F  <<  "\t\tCR: " << PtrTP->CR << "\t\tStrategy: " << PtrTP->strategy << "\t\tGenerations: " << PtrTP->generations << endl;
  73                 cout << "\t\t\tInitial fitness: " << oldfitness << endl;
  74                 cout << "\t\t\tFinal fitness: " <<  deme.extractBestIndividual().getFitness() << endl;
  75                 cout << "\t\t\tSeconds elapsed: " << dif << endl;
  76                 cout << "\t\t\tShutting down" << endl;
  77                 //log in logfile
  78                 *(PtrTP->Ptr_log) << PtrTP->generations * deme.size() << " " << (PtrTP->Ptr_pop->extractBestIndividual()).getFitness() << endl;
  79                 //sinal exit
  80                 *(PtrTP->isActive) = false;
  81                 PtrTP->exit->notify_one();
  82    }
  83    return 0;
  84 }
  85
  86
  87
  88
  89
  90 //******************************************************************************************
  91 //MPSO thread type
  92 //******************************************************************************************
  93
  94 void *MPSOthread(void *data)
  95 {
  96    threadParam *PtrTP;
  97    PtrTP = (threadParam *)data;
  98    Population deme;
  99    double oldfitness;
 100    vector <int> picks;
 101    GOProblem* problem;
 102    vector<double> LB, UB;
 103    MPSOalgorithm MPSO;
 104    rng_uint32_type rng;
 105    rng_double_type drng;
 106
 107         clock_t start,end;
 108         double dif;
 109
 110    {
 111         lock_type lock(*PtrTP->TPmutex);
 112         rng.seed(PtrTP->randomSeed);
 113         drng.seed(PtrTP->randomSeed);
 114                 deme=PtrTP->Ptr_pop->extractRandomDeme(PtrTP->NP,picks, drng);
 115                 problem = PtrTP->problem;
 116                 problem->getBounds(LB, UB);
 117                 MPSO.initMPSO(PtrTP->generations,LB.size(),PtrTP->omega,PtrTP->eta1,PtrTP->eta2,PtrTP->vcoeff, PtrTP->nswarms, rng());
 118    }
 119
 120    oldfitness = deme.extractBestIndividual().getFitness();
 121
 122    start=clock();
 123    deme = MPSO.evolve(deme, *problem);
 124    end=clock();
 125    dif = (double)(end-start) / (double)CLOCKS_PER_SEC;
 126
 127     {
 128         lock_type lock(*PtrTP->TPmutex);
 129         //insert deme in main population
 130                 PtrTP->Ptr_pop->insertDeme(deme,picks);
 131                 //log in cout
 132                 cout << "Thread ID: " <<  PtrTP->threadID << endl ;
 133                 cout << "\t\t\tMPSO:\t\t omega "<< PtrTP->omega  <<  "\t\teta1: " << PtrTP->eta1 <<  "\t\teta2: " << PtrTP->eta2 << "\t\tVcoeff: " << PtrTP->vcoeff<< "\t\tNswarms" <<PtrTP->vcoeff << "\t\tGenerations: " << PtrTP->generations << endl;
 134                 cout << "\t\t\tInitial fitness: " << oldfitness << endl;
 135                 cout << "\t\t\tFinal fitness: " <<  deme.extractBestIndividual().getFitness() << endl;
 136                 cout << "\t\t\tSeconds elapsed: " << dif << endl;
 137                 cout << "\t\t\tShutting down" << endl;
 138                 //log in logfile
 139                 *(PtrTP->Ptr_log) << PtrTP->generations * deme.size() << " " << (PtrTP->Ptr_pop->extractBestIndividual()).getFitness() << endl;
 140                 //sinal exit
 141                 *(PtrTP->isActive) = false;
 142         PtrTP->exit->notify_one();
 143     }
 144    return 0;
 145 }
 146
 147 //******************************************************************************************
 148 //PSO thread type
 149 //******************************************************************************************
 150
 151 void *PSOthread(void *data)
 152 {
 153    threadParam *PtrTP;
 154    PtrTP = (threadParam *)data;
 155    Population deme;
 156    double oldfitness;
 157    vector <int> picks;
 158    GOProblem* problem;
 159    vector<double> LB,UB;
 160    PSOalgorithm PSO;
 161    rng_uint32_type rng;
 162    rng_double_type drng;
 163
 164         clock_t start,end;
 165         double dif;
 166
 167    {
 168         lock_type lock(*PtrTP->TPmutex);
 169         rng.seed(PtrTP->randomSeed);
 170         drng.seed(PtrTP->randomSeed);
 171                 deme=PtrTP->Ptr_pop->extractRandomDeme(PtrTP->NP,picks, drng);
 172                 problem = PtrTP->problem;
 173                 problem->getBounds(LB, UB);
 174                 PSO.initPSO(PtrTP->generations,LB.size(),PtrTP->omega,PtrTP->eta1,PtrTP->eta2,PtrTP->vcoeff, rng());
 175    }
 176
 177    oldfitness = deme.extractBestIndividual().getFitness();
 178
 179    start=clock();
 180    deme = PSO.evolve(deme, *problem);
 181    end=clock();
 182    dif = (double)(end-start) / (double)CLOCKS_PER_SEC;
 183
 184    {
 185         lock_type lock(*PtrTP->TPmutex);
 186         //insert deme in main population
 187                 PtrTP->Ptr_pop->insertDeme(deme,picks);
 188                 //log in cout
 189                 cout << "Thread ID: " <<  PtrTP->threadID << endl ;
 190                 cout << "\t\t\tPSO:\t\t omega "<< PtrTP->omega  <<  "\t\teta1: " << PtrTP->eta1 <<  "\t\teta2: " << PtrTP->eta2 << "\t\tVcoeff: " << PtrTP->vcoeff << "\t\tGenerations: " << PtrTP->generations << endl;
 191                 cout << "\t\t\tInitial fitness: " << oldfitness << endl;
 192                 cout << "\t\t\tFinal fitness: " <<  deme.extractBestIndividual().getFitness() << endl;
 193                 cout << "\t\t\tSeconds elapsed: " << dif << endl;
 194                 cout << "\t\t\tShutting down" << endl;
 195                 //log in logfile
 196                 *(PtrTP->Ptr_log) << PtrTP->generations * deme.size() << " " << (PtrTP->Ptr_pop->extractBestIndividual()).getFitness() << endl;
 197                 //sinal exit
 198                 *(PtrTP->isActive) = false;
 199                 PtrTP->exit->notify_one();
 200    }
 201    return 0;
 202 }
 203
 204
 205
 206 //******************************************************************************************
 207 //SGA thread type
 208 //******************************************************************************************
 209
 210 void *SGAthread(void *data)
 211 {
 212    threadParam *PtrTP;
 213    PtrTP = (threadParam *)data;
 214    Population deme;
 215    double oldfitness;
 216    vector <int> picks;
 217    vector<double> LB,UB;
 218    SGAalgorithm SGA;
 219    rng_uint32_type rng;
 220    rng_double_type drng;
 221    GOProblem* problem;
 222
 223         clock_t start,end;
 224         double dif;
 225
 226    {
 227         lock_type lock(*PtrTP->TPmutex);
 228         rng.seed(PtrTP->randomSeed);
 229         drng.seed(PtrTP->randomSeed);
 230                 deme=PtrTP->Ptr_pop->extractRandomDeme(PtrTP->NP,picks, drng);
 231                 problem = PtrTP->problem;
 232                 problem->getBounds(LB, UB);
 233                 SGA.initSGA(PtrTP->generations,LB.size(),PtrTP->CRsga,PtrTP->M,PtrTP->insert_best, rng());
 234    }
 235
 236    oldfitness = deme.extractBestIndividual().getFitness();
 237
 238    start=clock();
 239    deme = SGA.evolve(deme, *problem);
 240    end=clock();
 241    dif = (double)(end-start) / (double)CLOCKS_PER_SEC;
 242
 243    {
 244         lock_type lock(*PtrTP->TPmutex);
 245         //insert deme in main population
 246                 PtrTP->Ptr_pop->insertDeme(deme,picks);
 247                 //log in cout
 248                 cout << "Thread ID: " <<  PtrTP->threadID << endl ;
 249                 cout << "\t\t\tSGA:\t\t CR "<< PtrTP->CRsga  <<  "\t\tM: " << PtrTP->M <<  "\t\tInsertBest: " << PtrTP->insert_best << "\t\tGenerations: " << PtrTP->generations << endl;
 250                 cout << "\t\t\tInitial fitness: " << oldfitness << endl;
 251                 cout << "\t\t\tFinal fitness: " <<  deme.extractBestIndividual().getFitness() << endl;
 252                 cout << "\t\t\tSeconds elapsed: " << dif << endl;
 253                 cout << "\t\t\tShutting down" << endl;
 254                 //log in logfile
 255                 *(PtrTP->Ptr_log) << PtrTP->generations * deme.size() << " " << (PtrTP->Ptr_pop->extractBestIndividual()).getFitness() << endl;
 256                 //sinal exit
 257                 *(PtrTP->isActive) = false;
 258                 PtrTP->exit->notify_one();
 259    }
 260    return 0;
 261 }
 262
 263
 264 //******************************************************************************************
 265 //SA-AN thread type
 266 //******************************************************************************************
 267
 268 void *ASAthread(void *data)
 269 {
 270    threadParam *PtrTP;
 271    PtrTP = (threadParam *)data;
 272    Population deme;
 273    double oldfitness;
 274    vector <int> picks;
 275    vector<double> LB,UB;
 276    ASAalgorithm ASA;
 277    rng_uint32_type rng;
 278    rng_double_type drng;
 279    GOProblem* problem;
 280
 281
 282         clock_t start,end;
 283         double dif;
 284
 285    {
 286         lock_type lock(*PtrTP->TPmutex);
 287         rng.seed(PtrTP->randomSeed);
 288         drng.seed(PtrTP->randomSeed);
 289                 deme=PtrTP->Ptr_pop->extractRandomDeme(PtrTP->NP,picks, drng);
 290                 problem = PtrTP->problem;
 291                 problem->getBounds(LB, UB);
 292                 unsigned int temp;
 293                 temp = rng();
 294                 ASA.initASA(PtrTP->generations,LB.size(),PtrTP->Ts,PtrTP->Tf, rng());
 295    }
 296
 297    oldfitness = deme.extractBestIndividual().getFitness();
 298
 299    start=clock();
 300    deme = ASA.evolve(deme[0], *problem);
 301    end=clock();
 302    dif = (double)(end-start) / (double)CLOCKS_PER_SEC;
 303
 304    {
 305         lock_type lock(*PtrTP->TPmutex);
 306         //insert deme in main population
 307                 PtrTP->Ptr_pop->insertDeme(deme,picks);
 308                 //log in cout
 309                 cout << "Thread ID: " <<  PtrTP->threadID << endl ;
 310                 cout << "\t\t\tASA:\t\t\t Ts "<< PtrTP->Ts  <<  "\t\tTf: " << PtrTP->Tf << "\t\tFunction Evaluations: " << PtrTP->generations << endl;
 311                 cout << "\t\t\tInitial fitness: " << oldfitness << endl;
 312                 cout << "\t\t\tFinal fitness: " <<  deme.extractBestIndividual().getFitness() << endl;
 313                 cout << "\t\t\tSeconds elapsed: " << dif << endl;
 314                 cout << "\t\t\tShutting down" << endl;
 315                 //log in logfile
 316                 *(PtrTP->Ptr_log) << PtrTP->generations * deme.size() << " " << (PtrTP->Ptr_pop->extractBestIndividual()).getFitness() << endl;
 317                 //sinal exit
 318                 *(PtrTP->isActive) = false;
 319                 PtrTP->exit->notify_one();
 320    }
 321    return 0;
 322 }
 323
 324