ReachabilityResult BestFirstReachabilitySearch::reachable(const PetriNet &net,
const MarkVal *m0,
const VarVal *v0,
const BoolVal *ba,
PQL::Condition *query){
StateAllocator<> allocator(net);
State* s0 = allocator.createState();
memcpy(s0->marking(), m0, sizeof(MarkVal) * net.numberOfPlaces());
memcpy(s0->intValuation(), v0, sizeof(VarVal) * net.numberOfIntVariables());
memcpy(s0->boolValuation(), ba, sizeof(BoolVal) * net.numberOfBoolVariables());
if(query->evaluate(*s0))
return ReachabilityResult(ReachabilityResult::Satisfied, "Satisfied initially", 0, 0);
//Initialize subclasses
initialize(query, net);
StateSet states(net);
_states = &states;
states.add(s0);
//PriorityQueue<State*> queue;
EnhancedPriorityQueue<State*> queue;
queue.push(0, s0);
//Allocate new state
State* ns = allocator.createState();
State* ns2 = allocator.createState();
State* ns3 = allocator.createState();
int count = 0;
BigInt expandedStates = 0;
BigInt exploredStates = 0;
BigInt transitionFired = 0;
size_t max = 1;
while(!queue.empty()){
if(count++ & 1<<17){
count = 0;
if(queue.size() > max)
max = queue.size();
this->reportProgress((double)(max - queue.size()) / ((double)(max)));
if(this->abortRequested())
return ReachabilityResult(ReachabilityResult::Unknown,
"Query aborted!");
}
//Take something out of the queue
State* s = queue.pop(depthFirst);
expandedStates++;
// Attempt to fire each transition
for(unsigned int t = 0; t < net.numberOfTransitions(); t++){
if(net.fire(t, s->marking(), s->intValuation(), s->boolValuation(), ns->marking(), ns->intValuation(), ns->boolValuation())){
//If it's new
transitionFired++;
if(states.add(ns)){
exploredStates++;
//Set parent and transition for the state
ns->setParent(s);
ns->setTransition(t);
//Test query
if(query->evaluate(*ns)){
//ns->dumpTrace(net);
return ReachabilityResult(ReachabilityResult::Satisfied,
"Query was satified!", expandedStates, exploredStates, transitionFired,0 , ns->pathLength(), ns->trace());
}
// Insert in queue, with given priority
double bestp = priority(ns, query, net);
queue.push(bestp, ns);
if(fireUntillNoBetter && net.fire(t, ns, ns2)){
if(query->evaluate(*ns2)){
ns2->setTransition(t);
ns2->setParent(ns);
return ReachabilityResult(ReachabilityResult::Satisfied,
"Query was satified!", expandedStates, exploredStates, transitionFired,0, ns2->pathLength(), ns2->trace());
}
double p = priority(ns2, query, net);
if(p <= bestp){
bestp = p;
while(net.fire(t, ns2, ns3) && (p = priority(ns3, query, net)) <= bestp){
ns3->setTransition(t);
ns3->setParent(ns2);
bestp = p;
State* tmp = ns2; //SWAP ns2 and ns3
ns2 = ns3;
ns3 = tmp;
exploredStates++;
if(query->evaluate(*ns2)){
return ReachabilityResult(ReachabilityResult::Satisfied,
"Query was satisfied!", expandedStates, exploredStates, transitionFired, 0, ns2->pathLength(), ns2->trace());
}
}
if(states.add(ns2)){
queue.push(priority(ns2, query, net), ns2);
ns2 = allocator.createState();
}
}
}
//Allocate new stake, as states take ownership
ns = allocator.createState();
}
}
}
}
return ReachabilityResult(ReachabilityResult::NotSatisfied,
"Query cannot be satisfied!", expandedStates, exploredStates, transitionFired,0);
}
ReachabilityResult MagicSearch::reachable(const PetriNet &net,
const MarkVal *m0,
const VarVal *v0,
PQL::Condition *query){
SmartStateAllocator<MEMORY_BOUND> allocator(net);
SmartStateSet states(net);
EnhancedPriorityQueue<Step> queue;
_dm = new Structures::DistanceMatrix(net);
{ //Compute constraints
ConstraintAnalysisContext context(net);
query->findConstraints(context);
if(context.canAnalyze)
contraints = context.retval;
}
//Create s0
SmartState* s0 = allocator.createStoredState();
memcpy(s0->marking(), m0, sizeof(MarkVal) * net.numberOfPlaces());
memcpy(s0->valuation(), v0, sizeof(VarVal) * net.numberOfVariables());
states.add(s0, s0->marking(), s0->valuation());
Step step0;
step0.depth = 0;
step0.lastApprox = INT_MAX;
step0.lastStored = 0;
step0.state = s0;
queue.push(0, step0);
//Temporary marking and valuation to work with
MarkVal tmpM[net.numberOfPlaces()];
VarVal tmpV[net.numberOfVariables()];
SmartState* ns = allocator.createStoredState();
SmartState* ls = allocator.createState();
//Statistics
int lastReport = 0;
BigInt expanded = 0, explored = 0;
size_t max = 1;
//Main loop
while(!queue.empty()){
// Report progress if needed
if(lastReport++ & 1<<17){
lastReport = 0;
if(queue.size() > max)
max = queue.size();
this->reportProgress((double)(max - queue.size()) / ((double)(max)));
if(this->abortRequested())
return ReachabilityResult(ReachabilityResult::Unknown,
"Query aborted!");
}
//Pop stuff of the queue
Step step = queue.pop(depthFirst);
expanded++; //Cound expanded states
// Get current state
const MarkVal* m;
const VarVal* v;
if(step.state->stored()){
m = step.state->marking();
v = step.state->valuation();
}else{
step.state->getState(net, tmpM, tmpV);
m = tmpM;
v = tmpV;
}
//Attempt to exclude by over-approx
if(step.lastApprox >= approxScale(step.depth)){
if(canExcludeByOverApprox(net, m, v))
continue;
step.lastApprox = 0;
}
for(unsigned int t = 0; t < net.numberOfTransitions(); t++){
//Fire the transition
if(net.fire(t, m, v, ns->marking(), ns->valuation())){
//Determine whether or not to store the entire state
bool storeCurrentState = step.lastStored >= storeScale(allocator.percentMemoryUsed());// storeScale(allocator.percentMemoryUsed());
SmartState* storeState;
if(storeCurrentState)
storeState = ns;
else
storeState = ls;
storeState->setParent(step.state);
storeState->setTransition(t);
//Add it to the state set
if(states.add(storeState, ns->marking(), ns->valuation())){
explored++; //Count explored states
//Test the query
if(query->evaluate(EvaluationContext(ns->marking(), ns->valuation()))){
printf("\nmemory usage: %f\n",allocator.percentMemoryUsed());
return ReachabilityResult(ReachabilityResult::Satisfied,
"Query was satified!",
expanded,
explored,
storeState->pathLength(),
storeState->trace());
}
//Make the next step
Step nextstep;
nextstep.depth = step.depth + 1;
nextstep.lastApprox = step.lastApprox + 1;
if(storeState == ns)
nextstep.lastStored = 0;
else
nextstep.lastStored = step.lastStored + 1;
nextstep.state = storeState;
//Push step on the queue
double p = priority(ns->marking(), ns->valuation(), query, net);
queue.push(p, nextstep);
//Allocate new memory, depending on what was stored
if(storeState == ns)
ns = allocator.createStoredState();
else
ls = allocator.createState();
}
}
}
}
return ReachabilityResult(ReachabilityResult::NotSatisfied,
"Query cannot be satisfied!",
expanded,
explored);
}
