spot  1.2.1a
dead_share.hh
1 // Copyright (C) 2012 Laboratoire de Recherche et Développement
2 // de l'Epita (LRDE).
3 //
4 // This file is part of Spot, a model checking library.
5 //
6 // Spot is free software; you can redistribute it and/or modify it
7 // under the terms of the GNU General Public License as published by
8 // the Free Software Foundation; either version 3 of the License, or
9 // (at your option) any later version.
10 //
11 // Spot is distributed in the hope that it will be useful, but WITHOUT
12 // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 // or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
14 // License for more details.
15 //
16 // You should have received a copy of the GNU General Public License
17 // along with this program. If not, see <http://www.gnu.org/licenses/>.
18 
19 #ifndef SPOT_FASTTGBAALGOS_EC_CONCUREC_DEAD_SHARE_HH
20 # define SPOT_FASTTGBAALGOS_EC_CONCUREC_DEAD_SHARE_HH
21 
22 #include <tuple>
23 
24 #include <stack>
25 #include <map>
26 
27 #include "fasttgbaalgos/ec/ec.hh"
28 #include "fasttgbaalgos/ec/deadstore.hh"
29 #include "fasttgbaalgos/ec/lowlink_stack.hh"
30 #include "fasttgbaalgos/ec/lazycheck.hh"
31 
32 #include "fasttgbaalgos/ec/concur/uf.hh"
33 #include "fasttgbaalgos/ec/concur/sharedhashtable.hh"
34 #include "fasttgbaalgos/ec/concur/openset.hh"
35 #include "concur_ec_stat.hh"
36 
37 #include "fasttgbaalgos/ec/opt/opt_tarjan_scc.hh"
38 #include "fasttgbaalgos/ec/opt/opt_dijkstra_scc.hh"
39 #include "fasttgbaalgos/ec/opt/opt_ndfs.hh"
40 #include "fasttgbaalgos/ec/unioncheck.hh"
41 
42 #include <sstream>
43 
44 namespace spot
45 {
46  // ----------------------------------------------------------------------
47  // Tarjan Concurrent SCC Computation
48  // ======================================================================
49 
56  {
57  public:
59  spot::uf* uf,
60  int thread_number,
61  int *stop,
62  int *stop_strong,
63  bool swarming,
64  std::string option = "");
65 
66  virtual bool check();
67 
68  virtual void dfs_push(fasttgba_state* q);
69 
70  virtual color get_color(const fasttgba_state* state);
71 
72  virtual void dfs_pop();
73 
74  virtual bool dfs_update (fasttgba_state* s);
75 
76  virtual void main ();
77 
78  virtual bool has_counterexample();
79 
80  virtual std::string csv();
81 
82  virtual std::chrono::milliseconds::rep get_elapsed_time();
83 
84  virtual int nb_inserted();
85 
86  protected:
87  spot::uf* uf_;
88  int tn_;
89  int * stop_;
90  int * stop_strong_;
91  std::chrono::time_point<std::chrono::system_clock> start;
92  std::chrono::time_point<std::chrono::system_clock> end;
93  int make_cpt_;
94  };
95 
96  // ----------------------------------------------------------------------
97  // Disjkstra Concurrent SCC Computation
98  // ======================================================================
99 
106  {
107  public:
109  spot::uf* uf,
110  int thread_number,
111  int *stop,
112  int *stop_strong,
113  bool swarming,
114  std::string option = "");
115 
116  virtual bool check();
117 
118  virtual void dfs_push(fasttgba_state* q);
119 
120  virtual color get_color(const fasttgba_state* state);
121 
122  virtual bool merge(fasttgba_state* d);
123 
124  virtual void dfs_pop();
125 
126  virtual void main ();
127 
128  virtual bool has_counterexample();
129 
130  virtual std::string csv()
131  {
132  return "dijkstra," + extra_info_csv();
133  }
134 
135  virtual std::chrono::milliseconds::rep
136  get_elapsed_time()
137  {
138  auto elapsed_seconds = std::chrono::duration_cast
139  <std::chrono::milliseconds>(end-start).count();
140  return elapsed_seconds;
141  }
142 
143  virtual int nb_inserted()
144  {
145  return make_cpt_;
146  }
147 
148  protected:
149  spot::uf* uf_;
150  int tn_;
151  int * stop_;
152  int * stop_strong_;
153  std::chrono::time_point<std::chrono::system_clock> start;
154  std::chrono::time_point<std::chrono::system_clock> end;
155  int make_cpt_;
156  };
157 
158  // ----------------------------------------------------------------------
159  // Tarjan Concurrent Emptiness Check
160  // ======================================================================
161 
165  {
166  public:
169  spot::uf* uf,
170  int thread_number,
171  int *stop,
172  int *stop_strong,
173  bool swarming,
174  std::string option = "-cs")
175  : concur_opt_tarjan_scc(i, uf, thread_number,
176  stop, stop_strong, swarming, option)
177  {
178  fastb_cpt_ = 0;
179  }
180 
182  virtual void dfs_pop();
183 
185  virtual bool dfs_update (fasttgba_state* s);
186 
189  virtual void fastbacktrack();
190 
192  virtual std::string csv();
193 
194  private:
195  int fastb_cpt_;
196  };
197 
198 
199  // ----------------------------------------------------------------------
200  // Dijkstra Concurrent Emptiness Check
201  // ======================================================================
202 
206  {
207  public:
210  spot::uf* uf,
211  int thread_number,
212  int *stop,
213  int *stop_strong,
214  bool swarming,
215  std::string option = "-cs")
216  : concur_opt_dijkstra_scc(i, uf, thread_number, stop,
217  stop_strong, swarming, option)
218  {
219  fastb_cpt_ = 0;
220  }
221 
223  virtual bool merge(fasttgba_state* d);
224 
226  virtual std::string csv();
227 
230  virtual void fastbacktrack();
231 
232  private:
233  int fastb_cpt_;
234  };
235 
236 
237  // ----------------------------------------------------------------------
238  // Reachability Concurrent Emptiness Check
239  // ======================================================================
240 
242  {
243  public:
246  spot::openset* os,
247  int thread_number,
248  int total_threads,
249  int *stop,
250  int *stop_terminal,
251  std::atomic<int>& giddle,
252  std::string option = "");
253 
255  virtual ~concur_reachability_ec();
256 
257  bool check();
258 
261  bool is_terminal(const fasttgba_state* );
262 
263  virtual bool has_counterexample();
264 
265  virtual std::string csv();
266 
267  virtual std::chrono::milliseconds::rep get_elapsed_time();
268 
269  virtual int nb_inserted();
270 
271  private:
272  int tn_;
273  int tt_;
274  int insert_cpt_;
275  int fail_cpt_;
276  bool iddle_;
277  int * stop_;
278  int * stop_terminal_;
279  spot::openset* os_;
280  const fasttgba* a_;
281  const instance_automaton* inst;
282  bool counterexample_;
283 
285  std::unordered_set<const fasttgba_state*,
288 
290  std::atomic<int>& giddle_;
291 
292  std::chrono::time_point<std::chrono::system_clock> start;
293  std::chrono::time_point<std::chrono::system_clock> end;
294  };
295 
296 
297  // ----------------------------------------------------------------------
298  // Weak Concurrent Emptiness Check
299  // ======================================================================
300 
302  {
303  public:
307  int thread_number,
308  int *stop,
309  int *stop_weak,
310  std::string option = "");
312  virtual ~concur_weak_ec();
313  void push_state(const spot::fasttgba_state* state);
314 
315  enum color {Alive, Dead, Unknown};
316 
317  color get_color(const spot::fasttgba_state* state);
318  void dfs_pop();
319  bool check();
320  void accepting_cycle_check(const fasttgba_state* left,
321  const fasttgba_state* right);
322  virtual bool has_counterexample();
323  virtual std::string csv();
324  virtual std::chrono::milliseconds::rep get_elapsed_time();
325  virtual int nb_inserted();
326 
327  private:
328  const instance_automaton* inst;
329  const fasttgba* a_;
330  sharedhashtable* sht_;
331 
332  int tn_;
333  int insert_cpt_;
334  int * stop_;
335  int * stop_weak_;
336  bool counterexample_;
337 
338  struct pair_state_iter
339  {
340  const spot::fasttgba_state* state;
341  fasttgba_succ_iterator* lasttr;
342  };
343 
344  std::vector<pair_state_iter> todo;
345 
347  typedef std::unordered_set<const fasttgba_state*,
349  fasttgba_state_ptr_equal> seen_map;
350  seen_map H;
351 
353  std::unordered_set<const fasttgba_state*,
354  fasttgba_state_ptr_hash,
356 
357  std::chrono::time_point<std::chrono::system_clock> start;
358  std::chrono::time_point<std::chrono::system_clock> end;
359  };
360 
361  // ======================================================================
362  // Fake Ec when needed.
363  // ======================================================================
364 
365 
366  class fake_ec : public concur_ec_stat
367  {
368  public:
370  fake_ec(int thread_number): tn_(thread_number)
371  {
372  (void) tn_;
373  }
374 
375  virtual
376  bool has_counterexample()
377  {
378  return false;
379  }
380 
381  virtual
382  std::string csv()
383  {
384  return "no_ec,0,0,0,0,0,0,0,0,0,0,0,0";
385  }
386 
387  virtual std::chrono::milliseconds::rep get_elapsed_time()
388  {
389  return 0;
390  }
391 
392  virtual int nb_inserted()
393  {
394  return 0;
395  }
396 
397  virtual bool check()
398  {
399  return false;
400  }
401 
402  private:
403  int tn_;
404  };
405 
406  // ======================================================================
407  // Reachability for only one thread.
408  // ======================================================================
410  {
411  public:
414  int thread_number,
415  int *stop);
416 
418  virtual ~reachability_ec();
419  bool check();
420  void push_state(const spot::fasttgba_state* state);
421  enum color {Alive, Dead, Unknown};
422  color get_color(const spot::fasttgba_state* state);
423 
426  bool is_terminal(const fasttgba_state* s);
427  virtual bool has_counterexample();
428  virtual std::string csv();
429  virtual std::chrono::milliseconds::rep get_elapsed_time();
430  virtual int nb_inserted();
431 
432  private:
433  int tn_;
434  int insert_cpt_;
435  int * stop_;
436  const fasttgba* a_;
437  const instance_automaton* inst;
438  bool counterexample_;
439 
440  struct pair_state_iter
441  {
442  const spot::fasttgba_state* state;
443  fasttgba_succ_iterator* lasttr;
444  };
445 
446  std::vector<pair_state_iter> todo;
448  typedef std::unordered_set<const fasttgba_state*,
450  fasttgba_state_ptr_equal> seen_map;
451  seen_map H;
452 
453  std::chrono::time_point<std::chrono::system_clock> start;
454  std::chrono::time_point<std::chrono::system_clock> end;
455  deadstore* deadstore_;
456  unsigned int transitions_cpt_;
457  unsigned int max_dfs_size_;
458  unsigned int memory_cost_;
459  unsigned int max_live_size_;
460  unsigned int update_cpt_;
461  };
462 
463 
464  // ----------------------------------------------------------------------
465  // Single Weak Emptiness Check
466  // ======================================================================
467 
468  class weak_ec : public concur_ec_stat
469  {
470  public:
473  int thread_number,
474  int *stop);
476  virtual ~weak_ec();
477  void push_state(const spot::fasttgba_state* state);
478 
479  enum color {Alive, Dead, Unknown};
480 
481  color get_color(const spot::fasttgba_state* state);
482  void dfs_pop();
483  bool check();
484  void accepting_cycle_check(const fasttgba_state* left,
485  const fasttgba_state* right);
486  virtual bool has_counterexample();
487  virtual std::string csv();
488  virtual std::chrono::milliseconds::rep get_elapsed_time();
489  virtual int nb_inserted();
490 
491  private:
492  const instance_automaton* inst;
493  const fasttgba* a_;
494  deadstore* deadstore_;
495 
496 
497  int tn_;
498  int insert_cpt_;
499  int * stop_;
500  bool counterexample_;
501 
502  struct pair_state_iter
503  {
504  const spot::fasttgba_state* state;
505  fasttgba_succ_iterator* lasttr;
506  };
507 
508  std::vector<pair_state_iter> todo;
509 
511  typedef std::unordered_set<const fasttgba_state*,
513  fasttgba_state_ptr_equal> seen_map;
514  seen_map H;
515 
516  std::chrono::time_point<std::chrono::system_clock> start;
517  std::chrono::time_point<std::chrono::system_clock> end;
518  unsigned int transitions_cpt_;
519  unsigned int max_dfs_size_;
520  unsigned int memory_cost_;
521  unsigned int max_live_size_;
522  unsigned int update_cpt_;
523  };
524 
525 
526 
527 
529  {
530  public:
532  int thread_number,
533  int *stop,
534  std::string option = "");
535  virtual void main ();
536  virtual bool check();
537  virtual bool has_counterexample();
538  virtual std::string csv();
539  virtual std::chrono::milliseconds::rep get_elapsed_time();
540  virtual int nb_inserted();
541  protected:
542  int tn_;
543  int * stop_;
544  std::chrono::time_point<std::chrono::system_clock> start;
545  std::chrono::time_point<std::chrono::system_clock> end;
546  int make_cpt_;
547  };
548 
550  {
551  public:
553  int thread_number,
554  int *stop,
555  std::string option = "");
556  virtual void main ();
557  virtual bool check();
558  virtual bool has_counterexample();
559  virtual std::string csv();
560  virtual std::chrono::milliseconds::rep get_elapsed_time();
561  virtual int nb_inserted();
562  protected:
563  int tn_;
564  int * stop_;
565  std::chrono::time_point<std::chrono::system_clock> start;
566  std::chrono::time_point<std::chrono::system_clock> end;
567  int make_cpt_;
568  };
569 
570 
572  {
573  public:
575  int thread_number,
576  int *stop,
577  std::string option = "");
578  virtual void main ();
579  virtual bool check();
580  virtual bool has_counterexample();
581  virtual std::string csv();
582  virtual std::chrono::milliseconds::rep get_elapsed_time();
583  virtual int nb_inserted();
584  protected:
585  int tn_;
586  int * stop_;
587  std::chrono::time_point<std::chrono::system_clock> start;
588  std::chrono::time_point<std::chrono::system_clock> end;
589  int make_cpt_;
590  };
591 
592 
594  {
595  public:
597  int thread_number,
598  int *stop,
599  std::string option = "");
600  virtual void main ();
601  virtual bool check();
602  virtual bool has_counterexample();
603  virtual std::string csv();
604  virtual std::chrono::milliseconds::rep get_elapsed_time();
605  virtual int nb_inserted();
606  protected:
607  int tn_;
608  int * stop_;
609  std::chrono::time_point<std::chrono::system_clock> start;
610  std::chrono::time_point<std::chrono::system_clock> end;
611  int make_cpt_;
612  };
613 
614 
616  {
617  public:
619  int thread_number,
620  int *stop,
621  std::string option = "");
622  virtual void main ();
623  virtual bool check();
624  virtual bool has_counterexample();
625  virtual std::string csv();
626  virtual std::chrono::milliseconds::rep get_elapsed_time();
627  virtual int nb_inserted();
628  protected:
629  int tn_;
630  int * stop_;
631  std::chrono::time_point<std::chrono::system_clock> start;
632  std::chrono::time_point<std::chrono::system_clock> end;
633  int make_cpt_;
634  };
635 
636 
637 
638 
639 
640 
642  class SPOT_API dead_share: public ec
643  {
644  public:
645 
648  {
649  FULL_TARJAN = 0,
650  FULL_DIJKSTRA = 1,
651  MIXED = 2,
652  FULL_TARJAN_EC = 3,
653  FULL_DIJKSTRA_EC = 4,
654  MIXED_EC = 5,
655  DECOMP_EC = 6,
656  REACHABILITY_EC = 7,
657  DECOMP_EC_SEQ = 8,
658  DECOMP_TACAS13_TARJAN = 9,
659  DECOMP_TACAS13_DIJKSTRA = 10,
660  DECOMP_TACAS13_NDFS = 11,
661  DECOMP_TACAS13_UC13 = 12,
662  DECOMP_TACAS13_TUC13 = 13
663  };
664 
672  int thread_number = 1,
673  DeadSharePolicy policy = FULL_TARJAN,
674  std::string option = "");
675 
677  virtual ~dead_share();
678 
681  bool check();
682 
687  virtual std::string csv();
688 
690  void dump_threads();
691 
692  protected:
697  int tn_;
699  std::chrono::milliseconds::rep max_diff;
700  std::vector<spot::concur_ec_stat*> chk;
701  int stop;
703  int stop_weak;
704  std::atomic<int> term_iddle_;
706  std::string option_;
707  };
708 }
709 
710 #endif // SPOT_FASTTGBAALGOS_EC_CONCUREC_DEAD_SHARE_HH
this class acts like a wrapper to the C code of the open_set.
Definition: public.hh:32
bool check()
Launch the emptiness check.
std::chrono::time_point< std::chrono::system_clock > end
start!
Definition: dead_share.hh:92
virtual bool check()
Launch the emptiness check.
virtual void main()
the main procedure
The class that will be used by thread performing a Tarjan SCC.
Definition: dead_share.hh:55
Definition: dead_share.hh:571
bool check()
Launch the emptiness check.
int stop
Stop the world variable.
Definition: dead_share.hh:701
Definition: fasttgba.hh:33
int * stop_
the thread identifier
Definition: dead_share.hh:89
Definition: concur_ec_stat.hh:28
Definition: dead_share.hh:528
virtual ~concur_reachability_ec()
A simple destructor.
int make_cpt_
stop!
Definition: dead_share.hh:589
std::chrono::time_point< std::chrono::system_clock > start
stop the world varibale
Definition: dead_share.hh:544
bool check()
Launch the emptiness check.
Definition: uf.hh:99
sharedhashtable * sht_
The shared Hash Table.
Definition: dead_share.hh:695
virtual void dfs_pop()
Pop states already explored.
std::chrono::time_point< std::chrono::system_clock > start
stop the world varibale
Definition: dead_share.hh:609
weak_ec(instanciator *i, int thread_number, int *stop)
A constuctor.
virtual void fastbacktrack()
Speed up the backtrack when the current state as been already marked dead by another thread...
virtual void main()
the main procedure
This class act as an interface for all classes.
Definition: fasttgba_state.hh:30
Definition: dead_share.hh:241
int * stop_strong_
stop the world varibale
Definition: dead_share.hh:152
concur_opt_tarjan_ec(instanciator *i, spot::uf *uf, int thread_number, int *stop, int *stop_strong, bool swarming, std::string option="-cs")
A constuctor.
Definition: dead_share.hh:168
int tn_
a reference to shared union find
Definition: dead_share.hh:88
instanciator * itor_
The instanciator.
Definition: dead_share.hh:696
virtual bool merge(fasttgba_state *d)
merge multiple states
Definition: dead_share.hh:615
Abstract class for states.
Definition: state.hh:40
virtual bool check()
Launch the emptiness check.
virtual bool check()
Launch the emptiness check.
Definition: unioncheck.hh:111
Wrapper Launch all threads.
Definition: dead_share.hh:642
int make_cpt_
stop!
Definition: dead_share.hh:633
std::chrono::time_point< std::chrono::system_clock > end
start!
Definition: dead_share.hh:566
Definition: unioncheck.hh:36
Compute the SCCs of a TGBA.
Definition: opt_tarjan_scc.hh:40
Definition: ec.hh:71
int make_cpt_
stop!
Definition: dead_share.hh:611
This is the Dijkstra SCC computation algorithm This class also include the optimisation for the live ...
Definition: opt_dijkstra_scc.hh:37
int tn_
The number of threads.
Definition: dead_share.hh:697
bool is_terminal(const fasttgba_state *s)
check wether a state is synchronised with a terminal state of the property automaton ...
int * stop_
the thread identifier
Definition: dead_share.hh:543
Definition: openset.hh:45
spot::openset * os_
The shared Open Set.
Definition: dead_share.hh:694
transform the previous algorithm into an emptiness check. Only refine specific methods ...
Definition: opt_dijkstra_scc.hh:126
DeadSharePolicy policy_
The current policy to use.
Definition: dead_share.hh:698
fake_ec(int thread_number)
A constuctor.
Definition: dead_share.hh:370
concur_opt_dijkstra_ec(instanciator *i, spot::uf *uf, int thread_number, int *stop, int *stop_strong, bool swarming, std::string option="-cs")
A constuctor.
Definition: dead_share.hh:209
DeadSharePolicy
The walk policy to be used by threads.
Definition: dead_share.hh:647
virtual void main()
the main procedure
virtual bool dfs_update(fasttgba_state *s)
the update for backedges
virtual color get_color(const fasttgba_state *state)
Storage for counterexample found or not.
A simple wrapper for an automaton.
Definition: ec.hh:40
virtual bool merge(fasttgba_state *d)
The update for backedges.
The class that will be used by thread performing a Dijkstra SCC.
Definition: dead_share.hh:105
An emptiness based on the dijkstra parallel computation algorithm above.
Definition: dead_share.hh:205
std::vector< spot::concur_ec_stat * > chk
Local data for each threads.
Definition: dead_share.hh:700
int * stop_
the thread identifier
Definition: dead_share.hh:630
std::chrono::time_point< std::chrono::system_clock > start
stop strong variable
Definition: dead_share.hh:153
virtual ~weak_ec()
A simple destructor.
virtual void fastbacktrack()
Speed up the backtrack when the current state as been already marked dead by another thread...
virtual void dfs_pop()
Pop states already explored.
Definition: dead_share.hh:549
std::string extra_info_csv()
Get extra informations.
virtual void dfs_pop()
Pop states already explored.
virtual void dfs_push(fasttgba_state *q)
Push a new state to explore.
Iterate over the successors of a state.
Definition: fasttgba_succ_iterator.hh:35
int * stop_
the thread identifier
Definition: dead_share.hh:608
virtual void main()
the main procedure
virtual std::string csv()
Display the csv of for this thread.
bool check()
Launch the emptiness check.
Definition: fasttgba_state.hh:76
Compute the SCCs of a TGBA.
Definition: opt_ndfs.hh:40
std::chrono::time_point< std::chrono::system_clock > end
start!
Definition: dead_share.hh:632
Definition: dead_share.hh:468
virtual ~reachability_ec()
A simple destructor.
int make_cpt_
stop!
Definition: dead_share.hh:93
std::chrono::time_point< std::chrono::system_clock > start
stop the world varibale
Definition: dead_share.hh:565
std::chrono::time_point< std::chrono::system_clock > end
start!
Definition: dead_share.hh:588
int make_cpt_
stop!
Definition: dead_share.hh:567
std::chrono::time_point< std::chrono::system_clock > start
stop the world varibale
Definition: dead_share.hh:587
std::chrono::time_point< std::chrono::system_clock > end
start!
Definition: dead_share.hh:610
virtual void main()
the main procedure
spot::uf * uf_
The shared Union Find.
Definition: dead_share.hh:693
reachability_ec(instanciator *i, int thread_number, int *stop)
A constuctor.
An emptiness based on the tarjan parallel computation algorithm above.
Definition: dead_share.hh:164
This class represent a dead store. For now it's just a set but it can be combined with bitstate hasin...
Definition: deadstore.hh:41
std::chrono::time_point< std::chrono::system_clock > start
stop strong varibale
Definition: dead_share.hh:91
int * stop_
the thread identifier
Definition: dead_share.hh:564
int * stop_strong_
stop the world varibale
Definition: dead_share.hh:90
Definition: dead_share.hh:409
virtual void dfs_push(fasttgba_state *q)
Push a new state to explore.
color
The color for a new State.
Definition: opt_dijkstra_scc.hh:72
virtual void main()
the main procedure
virtual bool check()
Launch the emptiness check.
Definition: sharedhashtable.hh:45
virtual bool check()
Launch the emptiness check.
std::string option_
option to pass to ec.
Definition: dead_share.hh:706
virtual bool check()
Launch the emptiness check.
virtual std::string csv()
Display the csv of for this thread.
bool is_terminal(const fasttgba_state *)
check wether a state is synchronised with a terminal state of the property automaton ...
Definition: fasttgba_state.hh:88
virtual void main()
the main procedure
virtual bool dfs_update(fasttgba_state *s)
the update for backedges
int tn_
a reference to shared union find
Definition: dead_share.hh:150
std::chrono::milliseconds::rep max_diff
Elapse time between 2 stops.
Definition: dead_share.hh:699
concur_reachability_ec(instanciator *i, spot::openset *os, int thread_number, int total_threads, int *stop, int *stop_terminal, std::atomic< int > &giddle, std::string option="")
A constuctor.
int stop_weak
Stop terminal variable.
Definition: dead_share.hh:703
virtual ~concur_weak_ec()
A simple destructor.
virtual color get_color(const fasttgba_state *state)
Access the color of a state.
color
The color for a new State.
Definition: opt_tarjan_scc.hh:82
std::chrono::time_point< std::chrono::system_clock > start
stop the world varibale
Definition: dead_share.hh:631
std::chrono::time_point< std::chrono::system_clock > end
start!
Definition: dead_share.hh:545
virtual bool check()
Launch the emptiness check.
int make_cpt_
stop!
Definition: dead_share.hh:546
Definition: dead_share.hh:366
int * stop_
the thread identifier
Definition: dead_share.hh:586
Definition: dead_share.hh:301
int stop_terminal
Stop terminal variable.
Definition: dead_share.hh:702
concur_weak_ec(instanciator *i, spot::sharedhashtable *sht, int thread_number, int *stop, int *stop_weak, std::string option="")
A constuctor.
Definition: ec.hh:28
virtual bool check()
Launch the emptiness check.
Definition: dead_share.hh:397
This class is the implementation of the tarjan-based emptiness check. It onlys needs to refine two me...
Definition: opt_tarjan_scc.hh:137
int stop_strong
Stop strong variable.
Definition: dead_share.hh:705
Definition: dead_share.hh:593

Please direct any question, comment, or bug report to the Spot mailing list at spot@lrde.epita.fr.
Generated on Fri Jun 5 2015 11:31:18 for spot by doxygen 1.8.9.1