void Manager::Initialize(int argc, char *argv[]) {
PARAMETERS->OutTime();
SetParameters();
PARALLEL->InitializeMPI(argc, argv);
InitializeSolver();
// must be after solver initialization
if (PARAMETERS->GetUseFlowKeeper())
FLOW_KEEPER->InitFlowAreas();
cout << "Initialization complete" << endl;
}
int SimpleTUI::run(int argc, char *argv[]) {
clock_t main_clock_start = clock();
EvalLog::curr_inst_start_time = get_time_second();
const char *program = (argc > 0) ? argv[0] : "despot";
argc -= (argc > 0);
argv += (argc > 0); // skip program name argv[0] if present
option::Stats stats(usage, argc, argv);
option::Option *options = new option::Option[stats.options_max];
option::Option *buffer = new option::Option[stats.buffer_max];
option::Parser parse(usage, argc, argv, options, buffer);
string solver_type = "DESPOT";
bool search_solver;
/* =========================
* Parse required parameters
* =========================*/
int num_runs = 1;
string simulator_type = "pomdp";
string belief_type = "DEFAULT";
int time_limit = -1;
/* =========================================
* Problem specific default parameter values
*=========================================*/
InitializeDefaultParameters();
/* =========================
* Parse optional parameters
* =========================*/
if (options[E_HELP]) {
cout << "Usage: " << program << " [options]" << endl;
option::printUsage(std::cout, usage);
return 0;
}
OptionParse(options, num_runs, simulator_type, belief_type, time_limit,
solver_type, search_solver);
/* =========================
* Global random generator
* =========================*/
Seeds::root_seed(Globals::config.root_seed);
unsigned world_seed = Seeds::Next();
unsigned seed = Seeds::Next();
Random::RANDOM = Random(seed);
/* =========================
* initialize model
* =========================*/
DSPOMDP *model = InitializeModel(options);
/* =========================
* initialize solver
* =========================*/
Solver *solver = InitializeSolver(model, solver_type, options);
assert(solver != NULL);
/* =========================
* initialize simulator
* =========================*/
Evaluator *simulator = NULL;
InitializeEvaluator(simulator, options, model, solver, num_runs,
main_clock_start, simulator_type, belief_type, time_limit,
solver_type);
simulator->world_seed(world_seed);
int start_run = 0;
/* =========================
* Display parameters
* =========================*/
DisplayParameters(options, model);
/* =========================
* run simulator
* =========================*/
RunEvaluator(model, simulator, options, num_runs, search_solver, solver,
simulator_type, main_clock_start, start_run);
simulator->End();
PrintResult(num_runs, simulator, main_clock_start);
return 0;
}
void SimpleTUI::RunEvaluator(DSPOMDP *model, Evaluator *simulator,
option::Option *options, int num_runs,
bool search_solver, Solver *&solver,
string simulator_type, clock_t main_clock_start,
int start_run) {
// Run num_runs simulations
vector<double> round_rewards(num_runs);
for (int round = start_run; round < start_run + num_runs; round++) {
default_out << endl
<< "####################################### Round " << round
<< " #######################################" << endl;
if (search_solver) {
if (round == 0) {
solver = InitializeSolver(model, "DESPOT", options);
default_out << "Solver: " << typeid(*solver).name() << endl;
simulator->solver(solver);
} else if (round == 5) {
solver = InitializeSolver(model, "POMCP", options);
default_out << "Solver: " << typeid(*solver).name() << endl;
simulator->solver(solver);
} else if (round == 10) {
double sum1 = 0, sum2 = 0;
for (int i = 0; i < 5; i++)
sum1 += round_rewards[i];
for (int i = 5; i < 10; i++)
sum2 += round_rewards[i];
if (sum1 < sum2)
solver = InitializeSolver(model, "POMCP", options);
else
solver = InitializeSolver(model, "DESPOT", options);
default_out << "Solver: " << typeid(*solver).name()
<< " DESPOT:" << sum1 << " POMCP:" << sum2 << endl;
}
simulator->solver(solver);
}
simulator->InitRound();
for (int i = 0; i < Globals::config.sim_len; i++) {
/*
default_out << "-----------------------------------Round " << round
<< " Step " << i << "-----------------------------------"
<< endl;*/
double step_start_t = get_time_second();
bool terminal = simulator->RunStep(i, round);
if (terminal)
break;
double step_end_t = get_time_second();
logi << "[main] Time for step: actual / allocated = "
<< (step_end_t - step_start_t) << " / " << EvalLog::allocated_time
<< endl;
simulator->UpdateTimePerMove(step_end_t - step_start_t);
logi << "[main] Time per move set to " << Globals::config.time_per_move
<< endl;
logi << "[main] Plan time ratio set to " << EvalLog::plan_time_ratio
<< endl;
// default_out << endl;
}
default_out << "Simulation terminated in " << simulator->step() << " steps"
<< endl;
double round_reward = simulator->EndRound();
round_rewards[round] = round_reward;
}
if (simulator_type == "ippc" && num_runs != 30) {
cout << "Exit without receiving reward." << endl
<< "Total time: Real / CPU = "
<< (get_time_second() - EvalLog::curr_inst_start_time) << " / "
<< (double(clock() - main_clock_start) / CLOCKS_PER_SEC) << "s"
<< endl;
exit(0);
}
}