Patrick Lühne
62ec122116
Reading the memory statistics requires a call to fopen, which uses the async-signal-unsafe function malloc. For this reason, interrupting Madagascar could lead to a crash when coinciding with allocations. Removing the memory statistics doesn’t do much harm, as this can still be read from an outside program such as the benchmark runner.
831 lines
21 KiB
C
831 lines
21 KiB
C
|
|
/* 2012 (C) Jussi Rintanen jrintanen.jr@gmail.com */
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "main.h"
|
|
#include "asyntax.h"
|
|
#include "intsets.h"
|
|
#include "ordintsets.h"
|
|
|
|
#include "interface.h"
|
|
#include "dimacsinput.h"
|
|
#include "clausedb.h"
|
|
|
|
#include "operators.h"
|
|
#include "tables.h"
|
|
//#include "staticpredicates.h"
|
|
#include "cleanup.h"
|
|
#include "invariants.h"
|
|
#include "scc.h"
|
|
#include "translate2sat.h"
|
|
|
|
#include <assert.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/times.h>
|
|
#include <sys/time.h>
|
|
#include <limits.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
|
|
#ifdef MULTICORE
|
|
#include <omp.h>
|
|
#endif
|
|
|
|
int numberOfGroundActionsAfterParsing = -1;
|
|
int numberOfStateVariablesAfterParsing = -1;
|
|
|
|
int numberOfGroundActionsAfterSimplification = -1;
|
|
int numberOfStateVariablesAfterSimplification = -1;
|
|
|
|
int maxSizeOfStronglyConnectedComponents = -1;
|
|
|
|
char state_for_random[256];
|
|
char dump_for_random[256];
|
|
|
|
char stri[1000];
|
|
|
|
long time10ms() { /* The time spent in user mode in 100ms */
|
|
struct tms TMS;
|
|
times(&TMS);
|
|
return TMS.tms_utime / (sysconf(_SC_CLK_TCK) / 100);
|
|
}
|
|
|
|
int abstimesec() {
|
|
struct timeval aux;
|
|
gettimeofday(&aux,NULL);
|
|
return aux.tv_sec;
|
|
}
|
|
|
|
int abstimeusec() {
|
|
struct timeval aux;
|
|
gettimeofday(&aux,NULL);
|
|
return aux.tv_usec;
|
|
}
|
|
|
|
intset test;
|
|
|
|
void givememorystatistics() {
|
|
char buf[30];
|
|
snprintf(buf, 30, "/proc/%u/statm", (unsigned)getpid());
|
|
FILE* pf = fopen(buf, "r");
|
|
|
|
|
|
if (pf) {
|
|
unsigned size; // total program size
|
|
unsigned resident;// resident set size
|
|
unsigned share;// shared pages
|
|
unsigned text;// text (code)
|
|
unsigned lib;// library
|
|
unsigned data;// data/stack
|
|
|
|
fscanf(pf, "%u %u %u %u %u %u", &size, &resident, &share, &text, &lib, &data);
|
|
|
|
printf("memoryConsumption:\n total: %.1f # [MB]\n", ((double)size)/256.0);
|
|
}
|
|
fclose(pf);
|
|
}
|
|
|
|
/***************** MALLOC STATISTICS *****************/
|
|
|
|
#define noSHOWMALLOCSTATS
|
|
|
|
#ifdef SHOWMALLOCSTATS
|
|
long statmallocs[1000];
|
|
|
|
void initstatmalloc() {
|
|
int i;
|
|
allocatedbyFE = 0.0;
|
|
for(i=0;i<1000;i++) statmallocs[i] = 0;
|
|
}
|
|
|
|
void showstatsmalloc() {
|
|
int i;
|
|
double sum;
|
|
sum = 0.0;
|
|
printf("Malloc statistics:\n");
|
|
for(i=0;i<1000;i++) {
|
|
if(statmallocs[i]) {
|
|
printf("%i: %.2f\n",i,((float)statmallocs[i])/1024.0/1024.0);
|
|
sum = sum + ((double)statmallocs[i])/1024.0/1024.0;
|
|
}
|
|
}
|
|
printf("TOTAL = %.2f\n",sum);
|
|
}
|
|
#endif
|
|
|
|
void *statmalloc(int n,int s) {
|
|
void *tmp;
|
|
tmp = malloc(s);
|
|
#ifdef SHOWMALLOCSTATS
|
|
statmallocs[n] += s;
|
|
assert(tmp);
|
|
#else
|
|
allocatedbyFE += s;
|
|
#endif
|
|
return tmp;
|
|
}
|
|
|
|
|
|
/******************** TIME OUTS ********************/
|
|
|
|
void timeouthandler(int i) {
|
|
printf("\nTimeout after %i seconds of real time.\n",flagRealTimeout);
|
|
givememorystatistics();
|
|
#ifdef SHOWMALLOCSTATS
|
|
showstatsmalloc();
|
|
#endif
|
|
exit(0);
|
|
}
|
|
|
|
float time2real(long dif) {
|
|
return ((float)dif)/100.0;
|
|
}
|
|
|
|
float timefromstart() {
|
|
return time2real(time10ms() - TIMEstart);
|
|
}
|
|
|
|
int numer(char c) {
|
|
return (c >= '0' && c <= '9');
|
|
}
|
|
|
|
void processheuristic(char *decls) {
|
|
int position,n;
|
|
|
|
HEURordmode = 0;
|
|
HEURordmin = 0;
|
|
HEURordrnd = 0;
|
|
|
|
HEURtime = 0;
|
|
HEURops = 0;
|
|
HEURchoice = 0;
|
|
|
|
HEURactions = 1;
|
|
HEURactionchoice = 0;
|
|
HEURactiondepthlimit = 0;
|
|
|
|
position = 0;
|
|
|
|
if(!numer(*decls)) {
|
|
printf("ERROR: Expected numeric option.\n");
|
|
exit(1);
|
|
}
|
|
|
|
do {
|
|
|
|
n = 0;
|
|
|
|
while(numer(*decls)) {
|
|
n = n*10 + (*(decls++) - '0');
|
|
}
|
|
|
|
if(*decls != 0 && *decls != ':') {
|
|
printf("ERROR: Number separator is : and not %c.\n",*decls);
|
|
exit(1);
|
|
}
|
|
|
|
switch(position) {
|
|
case 0: HEURordmode = n; break;
|
|
case 1: HEURordmin = n; break;
|
|
case 2: HEURordrnd = n; break;
|
|
case 3: HEURtime = n; break;
|
|
case 4: HEURops = n; break;
|
|
case 5: HEURchoice = n; break;
|
|
case 6: HEURactions = n; break;
|
|
case 7: HEURactionchoice = n; break;
|
|
case 8: HEURactiondepthlimit = n; break;
|
|
default: printf("ERROR: too many parameters.\n"); exit(1);
|
|
}
|
|
|
|
position += 1;
|
|
|
|
} while(*(decls++) == ':');
|
|
|
|
}
|
|
|
|
void printStatistics()
|
|
{
|
|
printf("\n\n# statistics in YAML format\n---\n");
|
|
|
|
printf("runtime:\n total: %.2f # [s]\n preprocessing: %.2f # [s]\n",
|
|
time2real(time10ms() - TIMEstart),
|
|
time2real(TIMEpreprocess - TIMEstart));
|
|
|
|
printf("maxLearnedClauseLength: %i\n",stats_longest_learned);
|
|
|
|
if (numberOfGroundActionsAfterParsing > -1)
|
|
printf("groundActions:\n afterParsing: %i\n",numberOfGroundActionsAfterParsing);
|
|
if (numberOfGroundActionsAfterSimplification > -1)
|
|
printf(" afterPreprocessing: %i\n",numberOfGroundActionsAfterSimplification);
|
|
if (numberOfStateVariablesAfterParsing > -1)
|
|
printf("stateVariables:\n afterParsing: %i\n",numberOfStateVariablesAfterParsing);
|
|
if (numberOfStateVariablesAfterSimplification > -1)
|
|
printf(" afterPreprocessing: %i\n",numberOfStateVariablesAfterSimplification);
|
|
|
|
if (maxSizeOfStronglyConnectedComponents > -1)
|
|
printf("stronglyConnectedComponents:\n maxSize: %i\n",maxSizeOfStronglyConnectedComponents);
|
|
|
|
int solutionIndex = -1;
|
|
|
|
for (int i = 0; seqs[i].sati; i++)
|
|
{
|
|
if (seqs[i].sati->value != 1)
|
|
continue;
|
|
|
|
solutionIndex = i;
|
|
break;
|
|
}
|
|
|
|
printf("plan:\n found: ");
|
|
|
|
if (solutionIndex < 0)
|
|
printf("false\n");
|
|
else
|
|
{
|
|
printf("true\n");
|
|
|
|
const auto planLength = seqs[solutionIndex].sati->nOfTPoints - 1;
|
|
|
|
int numberOfActions = 0;
|
|
|
|
const satinstance sati = seqs[solutionIndex].sati;
|
|
|
|
for (int t = 0; t < sati->nOfTPoints - 1; t++)
|
|
for (int i = 0; i < sati->nOfActions; i++)
|
|
if (vartruep(sati,TACT(i,t)))
|
|
numberOfActions++;
|
|
|
|
printf(" length: %i\n actions: %i\n", planLength, numberOfActions);
|
|
}
|
|
|
|
if(flagOutputDIMACS == 0) {
|
|
if (seqs[0].sati)
|
|
printf("iterations:\n");
|
|
int i = 0;
|
|
while(i*outputTimeStep+firstTimePoint < lastTimePoint && seqs[i].sati) {
|
|
printf(" - horizon: %i\n",seqs[i].sati->nOfTPoints-1);
|
|
printf(" result: ");
|
|
if (seqs[i].sati->value == 0)
|
|
printf("unsatisfiable");
|
|
else if (seqs[i].sati->value == 1)
|
|
printf("satisfiable");
|
|
else
|
|
printf("unknown");
|
|
printf("\n");
|
|
printf(" conflicts: %i\n",seqs[i].sati->conflicts);
|
|
printf(" decisions: %i\n",seqs[i].sati->decisions);
|
|
printf(" variables: %i\n",seqs[i].sati->nOfVars);
|
|
i += 1;
|
|
}// && seqs[i-1].sati->value != 1);
|
|
// } while(i*outputTimeStep+firstTimePoint < lastTimePoint);
|
|
}
|
|
|
|
printf("...\n");
|
|
}
|
|
|
|
void handleSIGINT()
|
|
{
|
|
printStatistics();
|
|
exit(0);
|
|
}
|
|
|
|
int main(int argc,char **argv) {
|
|
signal(SIGINT, handleSIGINT);
|
|
|
|
int i,j;
|
|
|
|
syntacticclass sclass;
|
|
|
|
nOfInputFiles = 0;
|
|
|
|
TIMEstartReal = time(NULL);
|
|
TIMEstart = time10ms();
|
|
#include "zPRINTDATE"
|
|
|
|
#ifdef __LP64__
|
|
printf(" amd64");
|
|
#else
|
|
printf(" x86-32");
|
|
#endif
|
|
|
|
#ifdef MULTICORE
|
|
printf(" multi-core");
|
|
#else
|
|
printf(" 1-core");
|
|
#endif
|
|
|
|
#ifdef VSIDS
|
|
printf("\n");
|
|
#else
|
|
printf(" (no VSIDS)\n");
|
|
#endif
|
|
|
|
#ifdef MULTICORE
|
|
nOfThreads = omp_get_num_procs();
|
|
printf("%i CPUS available\n",nOfThreads);
|
|
#endif
|
|
|
|
stats_longest_learned = 0;
|
|
|
|
/* Process command line options. */
|
|
|
|
flagShortCutHorizon = 5;
|
|
|
|
flagShowInput = 0;
|
|
flagPDDLadddel = 1;
|
|
flagRestartInterval = 60;
|
|
flagRestartScheme = 0;
|
|
flagPreprocessing = 0;
|
|
flagCEvariables = 1;
|
|
flagRandomSeedTime = 0;
|
|
flagNoInvariants = 0;
|
|
flagEliminateConverses = 1;
|
|
|
|
currentInputFile = 0;
|
|
outputfile = NULL;
|
|
|
|
#ifdef __LP64__
|
|
flagMemoryLimit = 8.0*1024.0; /* By default, use max 8 GB of memory. */
|
|
#else
|
|
flagMemoryLimit = 3500.0; /* By default, use max 3.5 GB of memory. */
|
|
#endif
|
|
|
|
flagOutputDIMACS = 0;
|
|
flagIPCplans = 0;
|
|
|
|
#if (MPDOWNLOAD || CMPDOWNLOAD)
|
|
PLANheuristic = 1;
|
|
HEURordmode = 1;
|
|
HEURordmin = 0;
|
|
HEURordrnd = 0;
|
|
HEURtime = 0;
|
|
HEURops = 1; /* This was 0 for long. */
|
|
HEURchoice = 0;
|
|
HEURactions = 50; /* This was 40 for the AIJ article. */
|
|
HEURactionchoice = 4;
|
|
HEURactiondepthlimit = 1;
|
|
#else
|
|
PLANheuristic = 0; /* By default don't use planning heuristic, but VSIDS. */
|
|
#endif
|
|
|
|
flagTimeout = 0;
|
|
flagRealTimeout = 0;
|
|
|
|
lastTimePoint = 3000;
|
|
outputTimeStep = 5;
|
|
|
|
firstTimePoint = 0;
|
|
debugOutput = 0;
|
|
|
|
#ifdef CMPDOWNLOAD
|
|
evalAlgorithm = 2;
|
|
paramC = 1.414214; /* Default: Algorithm C */
|
|
#else
|
|
evalAlgorithm = 1;
|
|
paramB = 0.9; /* Default: Algorithm B */
|
|
#endif
|
|
|
|
paramM = 20;
|
|
|
|
planFrontend = 1;
|
|
planSemantics = EStep;
|
|
|
|
filenamebase = NULL;
|
|
|
|
if(argc == 1) {
|
|
printf("\n");
|
|
printf("The command line parameters are the input file names and options:\n");
|
|
printf("-A n Run algorithm A with parameter n (range 1 to 50)"); if(evalAlgorithm==0) printf(" default -A %i.\n",paramA); else printf("\n");
|
|
printf("-B r Run algorithm B with parameter r (range 0.1 to 0.9999)"); if(evalAlgorithm==1) printf(" default -B %.2f.\n",paramB); else printf("\n");
|
|
printf("-C r Run algorithm C with parameter r (range 1.2 to 2.0)"); if(evalAlgorithm==2) printf(" default -C %.2f.\n",paramC); else printf("\n");
|
|
printf("-M n With algorithm B, use maximum n processes (default -M %i).\n",paramM);
|
|
printf("-S n Step for horizon lengths 0,n,2n,3n,... (default -S %i, algorithms A and B only)\n",outputTimeStep);
|
|
// printf("-H n Use SAT heuristic n.\n");
|
|
// printf("-pH n Use planning heuristic n (0 = none).\n");
|
|
printf("-F n Starting horizon length (default -F %i)\n",firstTimePoint);
|
|
printf("-T n Ending horizon length (default -T %i)\n",lastTimePoint);
|
|
printf("-P n Choose plan type n: (default -P 2)\n");
|
|
printf(" 0 = sequential plans\n");
|
|
printf(" 1 = A-step plans (Graphplan parallelism)\n");
|
|
printf(" 2 = E-step plans (Rintanen et al. 2004, 2006)\n");
|
|
// printf(" 3 = E-step plans (Ogata et al. 2004)\n");
|
|
printf("-O Write formulas in a file in DIMACS format instead of solving.\n");
|
|
printf("-X Don't use PDDL semantics for simultaneous v:=0 v:=1.\n");
|
|
printf("-Q Output plans in the IPC format.\n");
|
|
printf("-o [filename] Output plan to file.\n");
|
|
printf("-b [filename] Name for the DIMACS CNF files.\n");
|
|
printf("-t n Timeout n seconds of CPU time\n");
|
|
printf("-r n Timeout n seconds of real time\n");
|
|
printf("-m n Allocating max. n MB of memory (default -m %i)\n",(int)flagMemoryLimit);
|
|
printf("-N Don't compute invariants.\n");
|
|
printf("-c Don't eliminate converse literals.\n");
|
|
printf("-W Use time as the random seed (instead of seed 0).\n");
|
|
// printf("-Z n Select preprocessing.\n");
|
|
printf("-i n Restart interval is n (default -i %i).\n",flagRestartInterval);
|
|
printf("-R n Restart scheme n=0 constant n=1 Luby (default -R %i).\n",flagRestartScheme);
|
|
#ifdef CP3
|
|
printf("-E Use external preprocessor.\n");
|
|
#endif
|
|
// printf("-K n Add shortcuts for horizon n.\n");
|
|
// printf("-I Show input and auxiliary data in detail.\n");
|
|
// printf("-2 Use the closure of binary clauses to speed up propagation.\n");
|
|
// printf("-d b Level of debug output (default = 0).\n");
|
|
exit(0);
|
|
}
|
|
|
|
printf("Options:");
|
|
|
|
for(i=1;i<argc;i++) {
|
|
if(argv[i][0] != '-') {
|
|
printf(" file:%s",argv[i]);
|
|
nOfInputFiles += 1;
|
|
inputfiles[nOfInputFiles-1] = argv[i];
|
|
} else {
|
|
switch(argv[i][1]) {
|
|
case 'A': /* evaluation algorithm A */
|
|
if(!sscanf(argv[i+1],"%d",¶mA)) {
|
|
printf("The -A parameter %s is not an integer.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
evalAlgorithm = 0;
|
|
i++;
|
|
printf(" -A %i",paramA);
|
|
break;
|
|
case 'B': /* evaluation algorithm B */
|
|
if(!sscanf(argv[i+1],"%f",¶mB)) {
|
|
printf("The -B parameter %s is not an real.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
evalAlgorithm = 1;
|
|
i++;
|
|
printf(" -B %.2f",paramB);
|
|
break;
|
|
case 'C': /* evaluation algorithm C */
|
|
if(!sscanf(argv[i+1],"%f",¶mC)) {
|
|
printf("The -B parameter %s is not an real.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
evalAlgorithm = 2;
|
|
i++;
|
|
printf(" -C %.2f",paramC);
|
|
break;
|
|
case 'M':
|
|
if(!sscanf(argv[i+1],"%d",¶mM)) {
|
|
printf("The -M parameter %s is not an integer.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
i++;
|
|
printf(" -M %i",paramM);
|
|
break;
|
|
case 'H': /* Heuristic used by the solver */
|
|
PLANheuristic = 1;
|
|
processheuristic(argv[i+1]);
|
|
printf(" -H %s",argv[i+1]);
|
|
i++;
|
|
break;
|
|
case 'K': /* Shortcut horizon */
|
|
if(!sscanf(argv[i+1],"%d",&flagShortCutHorizon)) {
|
|
printf("The -K parameter %s is not an integer.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
i++;
|
|
printf(" -K %i",flagShortCutHorizon);
|
|
break;
|
|
case 'F': /* First time point to consider */
|
|
if(!sscanf(argv[i+1],"%d",&firstTimePoint)) {
|
|
printf("The -F parameter %s is not an integer.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
i++;
|
|
printf(" -F %i",firstTimePoint);
|
|
break;
|
|
case 'p': /* Outdated option */
|
|
printf("option not available any more.\n");
|
|
exit(1);
|
|
break;
|
|
case 'i': /* Restart interval */
|
|
if(!sscanf(argv[i+1],"%d",&flagRestartInterval)) {
|
|
printf("The -i parameter %s is not an integer.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
i++;
|
|
printf(" -i %i",flagRestartInterval);
|
|
break;
|
|
case 'R': /* Restart scheme */
|
|
if(!sscanf(argv[i+1],"%d",&flagRestartScheme)) {
|
|
printf("The -R parameter %s is not an integer.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
i++;
|
|
printf(" -R %i",flagRestartScheme);
|
|
break;
|
|
case 'T': /* Max time points to test */
|
|
if(!sscanf(argv[i+1],"%d",&lastTimePoint)) {
|
|
printf("The -T parameter %s is not an integer.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
i++;
|
|
printf(" -T %i",lastTimePoint);
|
|
break;
|
|
case 't': /* Time out */
|
|
if(!sscanf(argv[i+1],"%d",&flagTimeout)) {
|
|
printf("The -t parameter %s is not an integer.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
i++;
|
|
printf(" -t %i",flagTimeout);
|
|
break;
|
|
case 'r': /* Time out in Real time */
|
|
if(!sscanf(argv[i+1],"%d",&flagRealTimeout)) {
|
|
printf("The -r parameter %s is not an integer.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
i++;
|
|
printf(" -r %i",flagRealTimeout);
|
|
break;
|
|
case 'm': /* Memory limit */
|
|
if(!sscanf(argv[i+1],"%d",&j)) {
|
|
printf("The -m parameter %s is not an integer.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
flagMemoryLimit = (float)j;
|
|
i++;
|
|
printf(" -m %i",(int)flagMemoryLimit);
|
|
break;
|
|
case 'd': /* Debug output level */
|
|
if(!sscanf(argv[i+1],"%d",&debugOutput)) {
|
|
printf("The -d parameter %s is not an integer.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
i++;
|
|
printf(" -d %i",debugOutput);
|
|
break;
|
|
case 'o': /* Output file name */
|
|
outputfile=argv[i+1];
|
|
i++;
|
|
printf(" -o %s",outputfile);
|
|
break;
|
|
case 'b': /* Output file name for DIMACS CNF */
|
|
filenamebase=argv[i+1];
|
|
i++;
|
|
printf(" -b %s",filenamebase);
|
|
break;
|
|
case 'S': /* Step */
|
|
if(!sscanf(argv[i+1],"%d",&outputTimeStep)) {
|
|
printf("The -S parameter %s is not an integer.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
i++;
|
|
printf(" -S %i",outputTimeStep);
|
|
break;
|
|
case 'X': /* Don't use PDDL semantics for v:=0 v:=1 assigning 0 first and then 1, without causing contradiction. */
|
|
flagPDDLadddel = 0;
|
|
printf(" -X");
|
|
break;
|
|
case 'W': /* Use time as random seed, instead of seed 0. */
|
|
flagRandomSeedTime = 1;
|
|
printf(" -W");
|
|
break;
|
|
case 'Z': /* Preprocessing options */
|
|
if(!sscanf(argv[i+1],"%d",&flagPreprocessing)) {
|
|
printf("The -Z parameter %s is not an integer.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
i++;
|
|
printf(" -Z %i",flagPreprocessing);
|
|
break;
|
|
case 'O': /* Output to DIMACS instead of running integrated SAT solver */
|
|
flagOutputDIMACS = 1;
|
|
break;
|
|
case 'N': /* Don't compute invariants. */
|
|
flagNoInvariants = 1;
|
|
printf(" -N");
|
|
break;
|
|
case 'Q': /* Output to plans in IPC format */
|
|
flagIPCplans = 1;
|
|
break;
|
|
case 'Y': /* Dummy 1-parameter option (for ignoring commandline args. */
|
|
i++;
|
|
break;
|
|
case 'P': /* Parallel semantics */
|
|
if(!sscanf(argv[i+1],"%d",&j)) {
|
|
printf("The -P parameter %s is not an integer.\n",argv[i+1]);
|
|
exit(1);
|
|
}
|
|
switch(j) {
|
|
case 0: planSemantics = Sequ; break;
|
|
case 1: planSemantics = AStep; break;
|
|
case 2: planSemantics = EStep; break;
|
|
case 3: planSemantics = EStepOgata; break;
|
|
}
|
|
i++;
|
|
printf(" -P %i",j);
|
|
break;
|
|
case 'c':
|
|
flagEliminateConverses = 0;
|
|
printf(" -c");
|
|
break;
|
|
case 'I':
|
|
flagShowInput = 1;
|
|
printf(" -I");
|
|
break;
|
|
case 'D': /* Input file is a CNF in DIMACS format. */
|
|
planFrontend = 0;
|
|
printf(" -D");
|
|
break;
|
|
case 'E': /* Use (external) preprocessor. */
|
|
flagExternalPreprocessor = 1;
|
|
printf(" -E");
|
|
break;
|
|
default:
|
|
printf("ignoring %s\n",argv[i]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
if(flagRandomSeedTime) srandom(abstimeusec());
|
|
else srandom(0);
|
|
|
|
/***********************************************************************/
|
|
/***********************************************************************/
|
|
/************************** Show heuristics parameter settings *********/
|
|
|
|
#define noEXPLAINSETTINGS 1
|
|
|
|
#ifdef EXPLAINSETTINGS
|
|
|
|
switch(HEURops) {
|
|
case 0: printf("Will consider the first (arbitrary) action only.\n"); break;
|
|
case 1: printf("Will consider all actions available.\n"); break;
|
|
case 2: printf("Will consider last computed only.\n"); break;
|
|
}
|
|
|
|
switch(HEURtime) {
|
|
case 0: printf("Earliest"); break;
|
|
case 1: printf("Latest"); break;
|
|
case 2: printf("Earliest..Latest"); break;
|
|
}
|
|
switch(HEURchoice) {
|
|
case 0: printf(", chosen randomly.\n"); break;
|
|
case 1: printf(", chosen randomly (biased).\n"); break;
|
|
default: printf(", chosen according to weight.\n");
|
|
}
|
|
|
|
printf("Compute %i suggested actions.\n",HEURactions);
|
|
switch(HEURactionchoice) {
|
|
case 0:
|
|
printf("Choose between them randomly.\n"); break;
|
|
case 1:
|
|
printf("Choose suggested action of earliest time point.\n"); break;
|
|
case 3:
|
|
printf("Choose suggested action randomly.\n"); break;
|
|
case 4:
|
|
printf("Choose suggested action according to weight, with ties broken randomly.\n"); break;
|
|
}
|
|
|
|
if(HEURactiondepthlimit) printf("For multiple suggested, only go deeper.\n");
|
|
else printf("For multiple suggested, consider all.\n");
|
|
#endif
|
|
|
|
if(flagRealTimeout) {
|
|
alarm(flagRealTimeout);
|
|
signal(SIGALRM,timeouthandler);
|
|
}
|
|
|
|
#ifdef SHOWMALLOCSTATS
|
|
initstatmalloc();
|
|
#endif
|
|
|
|
/* ******************************************************************** */
|
|
/* ******************************************************************** */
|
|
/* ******************************************************************** */
|
|
|
|
#ifndef VSIDS
|
|
if(PLANheuristic == 0) {
|
|
fprintf(stderr,"ERROR: Trying to use VSIDS which was not compiled.\n");
|
|
exit(1);
|
|
}
|
|
#endif
|
|
|
|
|
|
if(planFrontend != 1) {
|
|
solve(DIMACSinput());
|
|
} else {
|
|
readfile();
|
|
printf("Domain: %s\nProblem: %s\n",domainname(),problemname());
|
|
|
|
// preprocessoperators();
|
|
//
|
|
// if(debugOutput >= 1) printf("Eliminating static...\n");
|
|
//
|
|
// eliminatestatic();
|
|
// // simplifysillyconditionals();
|
|
//
|
|
// if(debugOutput >= 1) printf("Grounding...\n");
|
|
//
|
|
// groundoperators();
|
|
|
|
if(debugOutput >= 1) printf("Grounding...\n");
|
|
|
|
NEWgroundoperators();
|
|
|
|
numberOfGroundActionsAfterParsing = nOfActions;
|
|
numberOfStateVariablesAfterParsing = nOfAtoms;
|
|
|
|
printf("Parser: %i ground actions and %i state variables\n",nOfActions,nOfAtoms);
|
|
|
|
if(flagShowInput) {
|
|
for(i=0;i<nOfActions;i++) printaction(i);
|
|
}
|
|
|
|
if(flagShowInput) {
|
|
printf("All atoms: ");
|
|
for(i=0;i<nOfAtoms;i++) {
|
|
printf(" %i:",i);
|
|
printatomi(i); fflush(stdout);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
if(debugOutput >= 1) printf("Cleaning up...\n");
|
|
|
|
cleanupoperators();
|
|
|
|
#ifdef SHOWMALLOCSTATS
|
|
showstatsmalloc();
|
|
#endif
|
|
|
|
TIMEinvariants = time10ms();
|
|
|
|
if(debugOutput >= 1) printf("Preparing to compute invariants...\n");
|
|
|
|
computeinvariants();
|
|
if(!flagNoInvariants) printf(" %.2f secs\n", time2real(time10ms() - TIMEinvariants));
|
|
|
|
simplifyoperatorsstatic();
|
|
|
|
eliminatestaticvariables();
|
|
|
|
if(flagEliminateConverses) mergecontras();
|
|
|
|
numberOfGroundActionsAfterSimplification = nOfActions;
|
|
numberOfStateVariablesAfterSimplification = nOfAtoms;
|
|
|
|
printf("Simplified: %i ground actions and %i state variables\n",nOfActions,nOfAtoms);
|
|
|
|
sortactions();
|
|
|
|
if(flagShowInput) {
|
|
for(i=0;i<nOfActions;i++) printaction(i);
|
|
}
|
|
|
|
/* Is the problem instance STRIPS, conjunctive PDDL, or general PDDL? */
|
|
sclass = goalclass();
|
|
for(i=0;i<nOfActions;i++) {
|
|
if(sclass == STRIPS && actionclass(i) == Conjunctive) sclass = Conjunctive;
|
|
if(actionclass(i) == GeneralPDDL) {
|
|
sclass = GeneralPDDL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch(sclass) {
|
|
case STRIPS: printf("Actions: STRIPS\n"); break;
|
|
case Conjunctive: printf("Actions: conjunctive\n"); break;
|
|
case GeneralPDDL: printf("Actions: general\n"); break;
|
|
}
|
|
|
|
TIMEdisaprepro = time10ms();
|
|
findoccurrences();
|
|
if(debugOutput > 0) printf("time %.2f for preprocessing for disabling graph\n", time2real(time10ms() - TIMEdisaprepro));
|
|
|
|
if(planSemantics == EStep) {
|
|
int maxsize;
|
|
TIMEdisabling = time10ms();
|
|
maxsize = scc(nOfActions);
|
|
maxSizeOfStronglyConnectedComponents = maxsize;
|
|
printf(" %.2f secs (max SCC size %i)\n",time2real(time10ms() - TIMEdisabling),maxsize);
|
|
}
|
|
|
|
TIMEpreprocess = time10ms();
|
|
|
|
encoding();
|
|
|
|
printStatistics();
|
|
|
|
}
|
|
|
|
#ifdef SHOWMALLOCSTATS
|
|
showstatsmalloc();
|
|
#endif
|
|
|
|
return 0;
|
|
}
|