Boosting expensive synchronizing heuristics

For automata, synchronization, the problem of bringing an automaton to a particular state regardless of its initial state, is important. It has several applications in practice and is related to a fifty-year-old conjecture on the length of the shortest synchronizing word. Although using shorter words increases the effectiveness in practice, finding a shortest one (which is not necessarily unique) is NP-hard. For this reason, there exist various heuristics in the literature. However, high-quality heuristics such as SynchroP producing relatively shorter sequences are very expensive and can take hours when the automaton has tens of thousands of states. The SynchroP heuristic has been frequently used as a benchmark to evaluate the performance of the new heuristics. In this work, we first improve the runtime of SynchroP and its variants by using algorithmic techniques. We then focus on adapting SynchroP for many-core architectures, and overall, we obtain more than 1000× speedup on GPUs compared to naive sequential implementation that has been frequently used as a benchmark to evaluate new heuristics in the literature. We also propose two SynchroP variants and evaluate their performance

Improved heuristics for W-set and K-tree generation on finite state machines

Finite State Machine (FSM) based testing methods utilize State Identification Sequences which are used to identify the states of a black box implementation as corresponding to the states of an FSM given as the specification. There are different types of state identification sequences. Some of these state identification sequences are not guaranteed to exist for all specifications. There is one particular type of state identification sequences, W-set based state identification sequences, which are known to exist for any minimal, deterministic, completely specified FSM. Although W-set based state identification sequences are known for a very long time, most of the works in FSM based testing literature do not prefer to use them when testing for an implementation without a reliable reset feature, since the length of W-set based state identifications sequences in this case are exponential in the cardinality of the W-sets. There are some recent works that suggest reducing the length of the W-set based state identification sequences. In fact, instead of W-sets, which are sets of preset experiments, these new methods can make use of so-called K-sets, which are set of adaptive experiments that again always exist. Furthermore, these new methods suggest applying not all elements of W–sets/K-sets, but instead an adaptive structure, called a K-tree is used to orchestrate the application of the elements of the K-set. However, there are no extensive experimental studies for these new methods. In addition, no algorithms are given for the construction of K-trees. In this work, we first present some W-set construction algorithms to construct better W-sets, in terms of both the cardinality and the total length of the sequences. We compare our W-set algorithms experimentally to the algorithms that exist in the literature. We also present algorithms to constructs K-sets and K-trees. Finally, we present an extensive experimental study for state identification sequences. The results show that, although W-set based state identification sequences have been considered practically infeasible due to the exponentially long sequences, the usage of K-trees make state identification sequences very short and practically usable. Utilizing K–sets in the generation of K–trees also yields better results than utilizing W–sets

Synchronizing heuristics: speeding up the slowest

Computing a shortest synchronizing word of an automaton is an NP–hard problem. Therefore, heuristics are used to compute short synchronizing words. SynchroP is among the best heuristics in the literature in terms of word lengths. The heuristic and its variants such as SynchroPL have been frequently used as a baseline to judge the quality of the words generated by the new heuristics. Although, its quality is good, the heuristics are significantly slow especially compared to much cheaper heuristics such as Greedy and Cycle. This makes them in- feasible for large-scale automatons. In this paper, we show how one can improve the time performance of SynchroP and its variants by avoiding unnecessary computations which makes these heuristics more competitive than they already are. Our experimental results show that for 2500 states, SynchroP can be made 70–160× faster, via the proposed optimizations. In particular, for 2500 states and 32 letters, the SynchroP execution reduces to 66 seconds from 4745 seconds. Furthermore, the suggested optimizations become more effective as the number of states in the automata increase