Newer
Older
/**
* @file GArgumentParser.cpp
*/
/* Copyright (C) Dr. Ruediger Berlich and Karlsruhe Institute of Technology
* (University of the State of Baden-Wuerttemberg and National Laboratory
* of the Helmholtz Association)
*
* Contact: info [at] gemfony (dot) com
*
* This file is part of the Geneva library, Gemfony scientific's optimization
* library.
*
* Geneva is free software: you can redistribute it and/or modify
* it under the terms of version 3 of the GNU Affero General Public License
* as published by the Free Software Foundation.
*
* Geneva is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with the Geneva library. If not, see <http://www.gnu.org/licenses/>.
*
* For further information on Gemfony scientific and Geneva, visit
* http://www.gemfony.com .
*/
#include "Examples/MATpbarpToOmegaPi/GArgumentParser.hh"
#include "ErrLogger/ErrLogger.hh"
namespace Gem
{
namespace Geneva
{
/************************************************************************************************/
/**
* A function that parses the command line for all required parameters
*/
bool parseCommandLine(
int argc,
char **argv,
std::string& configFile
, boost::uint16_t& parallelizationMode
, bool& serverMode
, std::string& ip
, unsigned short& port
, Gem::Common::serializationMode& serMode
) {
try{
// Check the command line options. Uses the Boost program options library.
po::options_description desc("Usage: evaluator [options]");
desc.add_options()
("help,h", "emit help message")
("configFile,c", po::value<std::string>(&configFile)->default_value(DEFAULTCONFIGFILE),
"The name of the configuration file holding further configuration options")
("parallelizationMode,p", po::value<boost::uint16_t>(¶llelizationMode)->default_value(DEFAULTPARALLELIZATIONMODE),
"Whether or not to run this optimization in serial mode (0), multi-threaded (1) or networked (2) mode")
("serverMode,s","Whether to run networked execution in server or client mode. The option only gets evaluated if \"--parallelizationMode=2\"")
("ip",po::value<std::string>(&ip)->default_value(DEFAULTIP), "The ip of the server")
("port",po::value<unsigned short>(&port)->default_value(DEFAULTPORT), "The port of the server")
("serMode", po::value<Gem::Common::serializationMode>(&serMode)->default_value(DEFAULTSERMODE),
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
"Specifies whether serialization shall be done in TEXTMODE (0), XMLMODE (1) or BINARYMODE (2)")
;
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
// Emit a help message, if necessary
if (vm.count("help")) {
ErrMsg << desc;
return false;
}
serverMode=false;
if (vm.count("parallelizationMode")) {
if(parallelizationMode > 2) {
ErrMsg << "Error: the \"-p\" or \"--parallelizationMode\" option may only assume the\n"
<< "values 0 (serial), 1 (multi-threaded) or 2 (networked). Leaving ..." << endmsg;
return false;
}
if(parallelizationMode == 2) if(vm.count("serverMode")) serverMode = true;
}
if(parallelizationMode != DEFAULTPARALLELIZATIONMODE || ip != DEFAULTIP || port != DEFAULTPORT){
std::string parModeString;
switch(parallelizationMode) {
case 0:
parModeString = "serial";
break;
case 1:
parModeString = "multi-threaded";
break;
case 2:
parModeString = "networked";
break;
};
Info << "\nRunning with the following command line options:\n"
<< "configFile = " << configFile << "\n"
<< "parallelizationMode = " << parModeString << "\n"
<< "serverMode = " << (serverMode?"true":"false") << "\n"
<< "ip = " << ip << "\n"
<< "port = " << port << "\n"
<< "serMode = " << serMode << "\n"
<< endmsg;
}
}
catch(...){
ErrMsg << "Error parsing the command line" << endmsg;
return false;
}
return true;
}
/************************************************************************************************/
/**
* A function that parses a config file for further parameters
*/
bool parseConfigFile(
const std::string& configFile,
boost::uint16_t& nProducerThreads
, boost::uint16_t& nEvaluationThreads
, std::size_t& populationSize
, std::size_t& nParents
, boost::uint32_t& maxIterations
, long& maxMinutes
, boost::uint32_t& reportIteration
, recoScheme& rScheme
, sortingMode& smode
, std::size_t& arraySize
, boost::uint32_t& processingCycles
, bool& returnRegardless
, boost::uint32_t& waitFactor
, unsigned& jMax
, unsigned& pbarMom
, int& errLogMode
) {
boost::uint16_t recombinationScheme=0;
bool verbose;
// Check the name of the configuation file
if(configFile.empty() || configFile == "empty" || configFile == "unknown") {
ErrMsg << "Error: Invalid configuration file name given: \"" << configFile << "\"" << endmsg;
return false;
}
try{
// Check the configuration file line options. Uses the Boost program options library.
po::options_description config("Allowed options");
config.add_options()
("nProducerThreads",po::value<boost::uint16_t>(&nProducerThreads)->default_value(DEFAULTNPRODUCERTHREADS),
"The amount of random number producer threads")
("nEvaluationThreads",po::value<boost::uint16_t>(&nEvaluationThreads)->default_value(DEFAULTNEVALUATIONTHREADS),
"The amount of threads processing individuals simultaneously")
("populationSize",po::value<std::size_t>(&populationSize)->default_value(DEFAULTPOPULATIONSIZE),
"The size of the super-population")
("nParents",po::value<std::size_t>(&nParents)->default_value(DEFAULTNPARENTS),
"The number of parents in the population") // Needs to be treated separately
("maxIterations", po::value<boost::uint32_t>(&maxIterations)->default_value(DEFAULTMAXITERATIONS),
"Maximum number of iterations in the population")
("maxMinutes", po::value<long>(&maxMinutes)->default_value(DEFAULTMAXMINUTES),
"The maximum number of minutes the optimization of the population should run")
("reportIteration",po::value<boost::uint32_t>(&reportIteration)->default_value(DEFAULTREPORTITERATION),
"The number of iterations after which information should be emitted in the super-population")
("rScheme",po::value<boost::uint16_t>(&recombinationScheme)->default_value(DEFAULTRSCHEME),
"The recombination scheme for the super-population")
("sortingScheme,o", po::value<sortingMode>(&smode)->default_value(DEFAULTSORTINGSCHEME),
"Determines whether sorting is done in MUCOMMANU (0), MUPLUSNU (1) or MUNU1PRETAIN (2) mode")
("arraySize", po::value<std::size_t>(&arraySize)->default_value(DEFAULTARRAYSIZE),
"The size of the buffer with random arrays in the random factory")
("verbose",po::value<bool>(&verbose)->default_value(DEFAULTVERBOSE),
"Whether additional information should be emitted")
("processingCycles", po::value<boost::uint32_t>(&processingCycles)->default_value(DEFAULTPROCESSINGCYCLES),
"The maximum number of cycles a client should perform mutations before it returns without success")
("returnRegardless", po::value<bool>(&returnRegardless)->default_value(DEFAULTRETURNREGARDLESS),
"Specifies whether results should be returned even if they are not better than before")
("waitFactor", po::value<boost::uint32_t>(&waitFactor)->default_value(DEFAULTGBTCWAITFACTOR),
"Influences the maximum waiting time of the GBrokerEA after the arrival of the first evaluated individuum")
("jMax", po::value<unsigned>(&jMax)->default_value(DEFAULTJMAX),"choose jmax")
("pbarMom", po::value<unsigned>(&pbarMom)->default_value(DEFAULTPBARMOM),"choose pbar momentum")
("errLogMode", po::value<int>(&errLogMode)->default_value(DEFAULTERRLOGMODE),
"choose mode for Error logger")
;
po::variables_map vm;
std::ifstream ifs(configFile.c_str());
if(!ifs.good()) {
ErrMsg << "Error accessing configuration file " << configFile << endmsg;
return false;
}
store(po::parse_config_file(ifs, config), vm);
notify(vm);
// Emit a help message, if necessary
if (vm.count("help")) {
Info << config << endmsg;
return false;
}
// Check the number of parents in the super-population
if(2*nParents > populationSize){
ErrMsg << "Error: Invalid number of parents inpopulation\n"
<< "nParents = " << nParents << "\n"
<< "populationSize = " << populationSize << endmsg;
return false;
}
// Workaround for assigment problem with rScheme
if(recombinationScheme==(boost::uint16_t)VALUERECOMBINE)
rScheme=VALUERECOMBINE;
else if(recombinationScheme==(boost::uint16_t)RANDOMRECOMBINE)
rScheme=RANDOMRECOMBINE;
else if(recombinationScheme==(boost::uint16_t)DEFAULTRECOMBINE)
rScheme=DEFAULTRECOMBINE;
else {
ErrMsg << "Error: Invalid recombination scheme in population: " << recombinationScheme << endmsg;
return false;
}
if(verbose){
Info << "\nRunning with the following options from " << configFile << ":\n"
<< "nProducerThreads = " << (boost::uint16_t)nProducerThreads << "\n" // boost::uint8_t not printable on gcc ???
<< "populationSize = " << populationSize << "\n"
<< "nParents = " << nParents << "\n"
<< "maxIterations = " << maxIterations << "\n"
<< "maxMinutes = " << maxMinutes << "\n"
<< "reportIteration = " << reportIteration << "\n"
<< "rScheme = " << (boost::uint16_t)rScheme << "\n"
<< "sortingScheme = " << smode << "\n"
<< "arraySize = " << arraySize << "\n"
<< "processingCycles = " << processingCycles << "\n"
<< "returnRegardless = " << (returnRegardless?"true":"false") << "\n"
<< "jMax = " << jMax << "\n"
<< "pbarMom = " << pbarMom << "\n"
<< "errLogMode = " << errLogMode << "\n"
<< endmsg;
}
}
catch(...){
ErrMsg << "Error parsing the configuration file " << configFile << endmsg;
return false;
}
return true;
}
/************************************************************************************************/
} /* namespace GenEvA */
} /* namespace Gem */