Commit 83e7f0fa authored by Ala-Eddine Ben-Salem's avatar Ala-Eddine Ben-Salem Committed by Alexandre Duret-Lutz
Browse files

GTA (Generalized Testing Automata) implementation

* src/ta/ta.cc, src/ta/ta.hh, src/ta/taexplicit.cc,
src/ta/taexplicit.hh, src/ta/taproduct.cc, src/ta/taproduct.hh,
src/taalgos/Makefile.am, src/taalgos/dotty.cc,
src/taalgos/emptinessta.cc, src/taalgos/minimize.cc,
src/taalgos/minimize.hh, src/taalgos/tgba2ta.cc, src/taalgos/tgba2ta.hh,
src/tgbatest/ltl2tgba.cc: changes introduced to add a new form of TA
called GTA (Generalized Testing Automata). GTA is a TA with acceptance-
conditions added on transitions.
parent c7f4b8e2
......@@ -34,6 +34,7 @@ namespace spot
{
index = i;
is_accepting = false;
condition = bddfalse;
}
scc_stack_ta::connected_component&
......
......@@ -70,7 +70,6 @@ namespace spot
virtual bool
is_livelock_accepting_state(const spot::state* s) const = 0;
virtual bool
is_initial_state(const spot::state* s) const = 0;
......@@ -80,6 +79,16 @@ namespace spot
virtual void
free_state(const spot::state* s) const = 0;
/// \brief Return the set of all acceptance conditions used
/// by this automaton.
///
/// The goal of the emptiness check is to ensure that
/// a strongly connected component walks through each
/// of these acceptiong conditions. I.e., the union
/// of the acceptiong conditions of all transition in
/// the SCC should be equal to the result of this function.
virtual bdd all_acceptance_conditions() const = 0;
};
/// Successor iterators used by spot::ta.
......@@ -107,11 +116,8 @@ namespace spot
is_stuttering_transition() const = 0;
bdd
current_acceptance_conditions() const
{
assert(!done());
return bddfalse;
}
current_acceptance_conditions() const = 0;
};
// A stack of Strongly-Connected Components
......@@ -128,6 +134,10 @@ namespace spot
bool is_accepting;
/// The bdd condition is the union of all acceptance conditions of
/// transitions which connect the states of the connected component.
bdd condition;
std::list<state*> rem;
};
......
......@@ -83,6 +83,13 @@ namespace spot
return (*i_)->condition;
}
bdd
ta_explicit_succ_iterator::current_acceptance_conditions() const
{
assert(!done());
return (*i_)->acceptance_conditions;
}
bool
ta_explicit_succ_iterator::is_stuttering_transition() const
{
......@@ -138,6 +145,10 @@ namespace spot
!= transitions_condition->end() && !transition_found); it_trans++)
{
transition_found = ((*it_trans)->dest == t->dest);
if (transition_found)
{
(*it_trans)->acceptance_conditions |= t->acceptance_conditions;
}
}
if (!transition_found)
......@@ -313,9 +324,10 @@ namespace spot
// ta_explicit
ta_explicit::ta_explicit(const tgba* tgba_,
ta_explicit::ta_explicit(const tgba* tgba, bdd all_acceptance_conditions,
state_ta_explicit* artificial_initial_state) :
tgba_(tgba_), artificial_initial_state_(artificial_initial_state)
tgba_(tgba), all_acceptance_conditions_(all_acceptance_conditions),
artificial_initial_state_(artificial_initial_state)
{
get_dict()->register_all_variables_of(&tgba_, this);
if (artificial_initial_state != 0)
......@@ -341,6 +353,7 @@ namespace spot
delete tgba_;
}
state_ta_explicit*
ta_explicit::add_state(state_ta_explicit* s)
{
......@@ -386,6 +399,19 @@ namespace spot
state_ta_explicit::transition* t = new state_ta_explicit::transition;
t->dest = dest;
t->condition = condition;
t->acceptance_conditions = bddfalse;
source->add_transition(t);
}
void
ta_explicit::create_transition(state_ta_explicit* source, bdd condition,
bdd acceptance_conditions, state_ta_explicit* dest)
{
state_ta_explicit::transition* t = new state_ta_explicit::transition;
t->dest = dest;
t->condition = condition;
t->acceptance_conditions = acceptance_conditions;
source->add_transition(t);
}
......
......@@ -41,8 +41,8 @@ namespace spot
class ta_explicit : public ta
{
public:
ta_explicit(const tgba* tgba_, state_ta_explicit* artificial_initial_state =
0);
ta_explicit(const tgba* tgba, bdd all_acceptance_conditions,
state_ta_explicit* artificial_initial_state = 0);
const tgba*
get_tgba() const;
......@@ -57,6 +57,10 @@ namespace spot
create_transition(state_ta_explicit* source, bdd condition,
state_ta_explicit* dest);
void
create_transition(state_ta_explicit* source, bdd condition,
bdd acceptance_conditions, state_ta_explicit* dest);
void
delete_stuttering_transitions();
// ta interface
......@@ -114,16 +118,32 @@ namespace spot
return states_set_;
}
/// \brief Return the set of all acceptance conditions used
/// by this automaton.
///
/// The goal of the emptiness check is to ensure that
/// a strongly connected component walks through each
/// of these acceptiong conditions. I.e., the union
/// of the acceptiong conditions of all transition in
/// the SCC should be equal to the result of this function.
bdd
all_acceptance_conditions() const
{
return all_acceptance_conditions_;;
}
private:
// Disallow copy.
ta_explicit(const ta_explicit& other);
ta_explicit&
operator=(const ta_explicit& other);
ta::states_set_t states_set_;
ta::states_set_t initial_states_set_;
const tgba* tgba_;
bdd all_acceptance_conditions_;
state_ta_explicit* artificial_initial_state_;
ta::states_set_t states_set_;
ta::states_set_t initial_states_set_;
};
......@@ -136,6 +156,7 @@ namespace spot
struct transition
{
bdd condition;
bdd acceptance_conditions;
state_ta_explicit* dest;
};
......@@ -201,6 +222,8 @@ namespace spot
void
free_transitions();
private:
const state* tgba_state_;
const bdd tgba_condition_;
......@@ -232,6 +255,9 @@ namespace spot
virtual bdd
current_condition() const;
virtual bdd
current_acceptance_conditions() const;
virtual bool
is_stuttering_transition() const;
......
......@@ -190,6 +190,7 @@ namespace spot
//if stuttering transition, the TA automata stays in the same state
current_state_ = new state_ta_product(source_->get_ta_state(),
kripke_current_dest_state->clone());
current_acceptance_conditions_ = bddfalse;
return;
}
......@@ -197,6 +198,8 @@ namespace spot
{
current_state_ = new state_ta_product(ta_succ_it_->current_state(),
kripke_current_dest_state->clone());
current_acceptance_conditions_
= ta_succ_it_->current_acceptance_conditions();
return;
}
......@@ -249,6 +252,19 @@ namespace spot
return current_condition_;
}
bdd
ta_succ_iterator_product::current_acceptance_conditions() const
{
// assert(!done());
// bdd kripke_source_condition = kripke_->state_condition(source_->get_kripke_state());
// state * kripke_succ_it_current_state = kripke_succ_it_->current_state();
// bdd kripke_current_dest_condition = kripke_->state_condition(kripke_succ_it_current_state);
// delete kripke_succ_it_current_state;
// return bdd_setxor(kripke_source_condition, kripke_current_dest_condition);
return current_acceptance_conditions_;
}
////////////////////////////////////////////////////////////
// ta_product
......@@ -392,6 +408,12 @@ namespace spot
return is_hole_state;
}
bdd
ta_product::all_acceptance_conditions() const
{
return get_ta()->all_acceptance_conditions();
}
bdd
ta_product::get_state_condition(const spot::state* s) const
{
......
......@@ -97,6 +97,9 @@ namespace spot
bdd
current_condition() const;
bdd
current_acceptance_conditions() const;
bool
is_stuttering_transition() const;
......@@ -121,6 +124,7 @@ namespace spot
tgba_succ_iterator* kripke_succ_it_;
state_ta_product* current_state_;
bdd current_condition_;
bdd current_acceptance_conditions_;
bool is_stuttering_transition_;
bdd kripke_source_condition;
state * kripke_current_dest_state;
......@@ -173,10 +177,12 @@ namespace spot
virtual bool
is_hole_state_in_ta_component(const spot::state* s) const;
virtual bdd
get_state_condition(const spot::state* s) const;
virtual bdd
all_acceptance_conditions() const;
virtual void
free_state(const spot::state* s) const;
......
......@@ -25,7 +25,7 @@ AM_CXXFLAGS = $(WARNING_CXXFLAGS)
taalgosdir = $(pkgincludedir)/taalgos
taalgos_HEADERS = \
sba2ta.hh \
tgba2ta.hh \
dotty.hh \
reachiter.hh \
stats.hh \
......@@ -33,10 +33,9 @@ taalgos_HEADERS = \
minimize.hh \
emptinessta.hh
noinst_LTLIBRARIES = libtaalgos.la
libtaalgos_la_SOURCES = \
sba2ta.cc \
tgba2ta.cc \
dotty.cc \
reachiter.cc \
stats.cc \
......
......@@ -119,7 +119,8 @@ namespace spot
os_ << " " << in << " -> " << out << " [label=\"";
escape_str(os_, bdd_format_accset(t_automata_->get_dict(),
si->current_condition()))
si->current_condition()) + "\n" + bdd_format_accset(
t_automata_->get_dict(), si->current_acceptance_conditions()))
<< "\"]" << std::endl;
......
......@@ -30,6 +30,7 @@
#include "emptinessta.hh"
#include "misc/memusage.hh"
#include <math.h>
#include "tgba/bddprint.hh"
namespace spot
{
......@@ -51,6 +52,12 @@ namespace spot
// We use five main data in this algorithm:
// * scc: a stack of strongly connected components (SCC)
scc;
// * arc, a stack of acceptance conditions between each of these SCC,
std::stack<bdd> arc;
// * h: a hash of all visited nodes, with their order,
// (it is called "Hash" in Couvreur's paper)
numbered_state_heap* h =
......@@ -108,6 +115,7 @@ namespace spot
h->insert(init, ++num);
scc.push(num);
arc.push(bddfalse);
ta_succ_iterator* iter = a_->succ_iter(init);
iter->first();
......@@ -187,6 +195,9 @@ namespace spot
}
dec_depth(scc.rem().size());
scc.pop();
assert(!arc.empty());
arc.pop();
}
delete succ;
......@@ -201,6 +212,8 @@ namespace spot
// Fetch the values destination state we are interested in...
state* dest = succ->current_state();
bdd acc_cond = succ->current_acceptance_conditions();
bool curr_is_livelock_hole_state_in_ta_component =
(a_->is_hole_state_in_ta_component(curr))
&& a_->is_livelock_accepting_state(curr);
......@@ -228,6 +241,7 @@ namespace spot
// for later processing.
h->insert(dest, ++num);
scc.push(num);
arc.push(acc_cond);
ta_succ_iterator* iter = a_->succ_iter(dest);
iter->first();
......@@ -265,13 +279,18 @@ namespace spot
while (threshold < scc.top().index)
{
assert(!scc.empty());
assert(!arc.empty());
acc |= scc.top().is_accepting;
acc_cond |= scc.top().condition;
acc_cond |= arc.top();
rem.splice(rem.end(), scc.rem());
scc.pop();
arc.pop();
}
// Note that we do not always have
// threshold == scc.top().index
// after this loop, the SSCC whose index is threshold might have
......@@ -279,13 +298,23 @@ namespace spot
// Accumulate all acceptance conditions into the merged SSCC.
scc.top().is_accepting |= acc;
scc.top().condition |= acc_cond;
scc.rem().splice(scc.rem().end(), rem);
if (scc.top().is_accepting)
bool is_accepting_sscc = (scc.top().is_accepting)
|| (scc.top().condition == a_->all_acceptance_conditions());
if (is_accepting_sscc)
{
clear(h, todo, init_set);
trace
<< "PASS 1: SUCCESS" << std::endl;
trace
<< "PASS 1: scc.top().condition : " << bdd_format_accset(a_->get_dict(),
scc.top().condition) << std::endl;
trace
<< "PASS 1: a_->all_acceptance_conditions() : " << bdd_format_accset(a_->get_dict(),
a_->all_acceptance_conditions()) << std::endl;
return true;
}
......
......@@ -37,6 +37,7 @@
#include "ta/taproduct.hh"
#include "taalgos/statessetbuilder.hh"
#include "tgba/tgbaexplicit.hh"
#include "tgba/bddprint.hh"
namespace spot
{
......@@ -75,7 +76,7 @@ namespace spot
build_result(const ta* a, std::list<hash_set*>& sets)
{
tgba_explicit_number* tgba = new tgba_explicit_number(a->get_dict());
ta_explicit* ta = new ta_explicit(tgba);
ta_explicit* ta = new ta_explicit(tgba, a->all_acceptance_conditions());
// For each set, create a state in the tgbaulting automaton.
// For a state s, state_num[s] is the number of the state in the minimal
......@@ -111,7 +112,7 @@ namespace spot
bool is_accepting_state = a->is_accepting_state(src);
bool is_livelock_accepting_state = a->is_livelock_accepting_state(src);
state_ta_explicit* new_src = new state_ta_explicit(tgba_state,
state_ta_explicit* new_src = new state_ta_explicit(tgba_state->clone(),
tgba_condition, is_initial_state, is_accepting_state,
is_livelock_accepting_state);
......@@ -150,7 +151,7 @@ namespace spot
bool is_livelock_accepting_state = a->is_livelock_accepting_state(
dst);
state_ta_explicit* new_dst = new state_ta_explicit(tgba_state,
state_ta_explicit* new_dst = new state_ta_explicit(tgba_state->clone(),
tgba_condition, is_initial_state, is_accepting_state,
is_livelock_accepting_state);
......@@ -169,7 +170,7 @@ namespace spot
else if (is_initial_state)
ta->add_to_initial_states_set(new_dst);
ta->create_transition(ta_src, succit->current_condition(), ta_dst);
ta->create_transition(ta_src, succit->current_condition(), succit->current_acceptance_conditions(), ta_dst);
}
delete succit;
......@@ -245,7 +246,7 @@ namespace spot
hash_map state_set_map;
// Size of ta_
unsigned size = states_set.size();
unsigned size = states_set.size() + 6;
// Use bdd variables to number sets. set_num is the first variable
// available.
unsigned set_num = ta_->get_dict()->register_anonymous_variables(size, ta_);
......@@ -347,6 +348,11 @@ namespace spot
typedef std::map<bdd, hash_set*, bdd_less_than> bdd_states_map;
bool did_split = true;
unsigned num = set_num;
set_num++;
used_var[num] = 1;
free_var.erase(num);
bdd bdd_false_acceptance_condition = bdd_ithvar(num);
while (did_split)
{
......@@ -373,7 +379,14 @@ namespace spot
hash_map::const_iterator i = state_set_map.find(dst);
assert(i != state_set_map.end());
f |= (bdd_ithvar(i->second) & si->current_condition());
bdd current_acceptance_conditions =
si->current_acceptance_conditions();
if (current_acceptance_conditions == bddfalse)
current_acceptance_conditions
= bdd_false_acceptance_condition;
f |= (bdd_ithvar(i->second) & si->current_condition()
& current_acceptance_conditions);
trace << "--------------f: " << bdd_format_accset(ta_->get_dict(),f) << std::endl;;
}
delete si;
......@@ -470,7 +483,7 @@ namespace spot
std::list<hash_set*>::iterator itdone;
for (itdone = done.begin(); itdone != done.end(); ++itdone)
delete *itdone;
delete ta_;
//delete ta_;
return res;
}
......
......@@ -30,6 +30,7 @@ namespace spot
ta*
minimize_ta(const ta* ta_);
/// @}
}
......
// Copyright (C) 2010, 2011 Laboratoire de Recherche et Developpement
// de l Epita (LRDE).
//
// This file is part of Spot, a model checking library.
//
// Spot is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Spot 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 General Public
// License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Spot; see the file COPYING. If not, write to the Free
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.
#include "ltlast/atomic_prop.hh"
#include "ltlast/constant.hh"
#include "tgba/formula2bdd.hh"
#include "misc/bddop.hh"
#include <cassert>
#include "ltlvisit/tostring.hh"
#include <iostream>
#include "tgba/bddprint.hh"
#include "tgbaalgos/gtec/nsheap.hh"
#include <stack>
#include "tgba2ta.hh"
#include "taalgos/statessetbuilder.hh"
using namespace std;
namespace spot
{
ta*
tgba_to_ta(const tgba* tgba_, bdd atomic_propositions_set_,
bool artificial_initial_state_mode,
bool artificial_livelock_accepting_state_mode, bool degeneralized)
{
ta_explicit* ta;
std::stack<state_ta_explicit*> todo;
// build Initial states set:
state* tgba_init_state = tgba_->get_init_state();
if (artificial_initial_state_mode)
{
state_ta_explicit* ta_init_state = new state_ta_explicit(
tgba_init_state->clone(), bddtrue, true);
ta = new spot::ta_explicit(tgba_, tgba_->all_acceptance_conditions(),ta_init_state);
}
else
{
ta = new spot::ta_explicit(tgba_, tgba_->all_acceptance_conditions());
}
bdd tgba_condition = tgba_->support_conditions(tgba_init_state);
bdd satone_tgba_condition;
while ((satone_tgba_condition = bdd_satoneset(tgba_condition,
atomic_propositions_set_, bddtrue)) != bddfalse)
{
tgba_condition -= satone_tgba_condition;
state_ta_explicit* init_state;
if (degeneralized)
{
init_state = new state_ta_explicit(tgba_init_state->clone(),
satone_tgba_condition, true,
((tgba_sba_proxy*) tgba_)->state_is_accepting(tgba_init_state));
}
else
{
init_state = new state_ta_explicit(tgba_init_state->clone(),
satone_tgba_condition, true, false);
}
state_ta_explicit* s = ta->add_state(init_state);
assert(s == init_state);
ta->add_to_initial_states_set(s);
todo.push(init_state);
}
tgba_init_state->destroy();
while (!todo.empty())
{
state_ta_explicit* source = todo.top();
todo.pop();
tgba_succ_iterator* tgba_succ_it = tgba_->succ_iter(
source->get_tgba_state());
for (tgba_succ_it->first(); !tgba_succ_it->done(); tgba_succ_it->next())
{
const state* tgba_state = tgba_succ_it->current_state();
bdd tgba_condition = tgba_succ_it->current_condition();
bdd tgba_acceptance_conditions =
tgba_succ_it->current_acceptance_conditions();
bdd satone_tgba_condition;
while ((satone_tgba_condition = bdd_satoneset(tgba_condition,
atomic_propositions_set_, bddtrue)) != bddfalse)
{
tgba_condition -= satone_tgba_condition;
bdd all_props = bddtrue;
bdd dest_condition;
if (satone_tgba_condition == source->get_tgba_condition())
while ((dest_condition = bdd_satoneset(all_props,
atomic_propositions_set_, bddtrue)) != bddfalse)
{
all_props -= dest_condition;
state_ta_explicit* new_dest;
if (degeneralized)
{
new_dest = new state_ta_explicit(tgba_state->clone(),
dest_condition, false,
((tgba_sba_proxy*) tgba_)->state_is_accepting(
tgba_state));
}