Finite Automata Implementations Considering CPU Cache J. Holub

Transcription

1 Finite Automata Implementations Consiering CPU Cache J. Holub The finite automata are mathematical moels for finite state systems. More general finite automaton is the noneterministic finite automaton (NFA) that cannot be irectly use. It is usually transforme to the eterministic finite automaton (DFA) that then runs in time (n), where n is the size of the input text. We present two main approaches to practical implementation of DFA consiering CPU cache. The first approach (represente by Table Driven an Har Coe implementations) is suitable forautomata being run very frequently, typically having cycles. The other approach is suitable for a collection of automata from which various automata are retrieve an then run. This secon kin of automata are expecte to be cyclefree. Keywors: eterministic finite automaton, CPU cache, implementation. 1 Introuction The original formal stuy of finite state systems (neural nets) is from 193 by McCulloch an Pitts [1]. In 1956 Kleene [13] moele the neural nets of McCulloch an Pitts by finite automata. In that time similar moels were presente by Huffman [12], Moore [17], an Mealy [15]. In 1959, Rabin an Scott introuce noneterministic finite automata (NFA) in [21]. The finite automata theory is a well evelope theory. It eals with regular languages, regular expressions, regular grammars, NFAs, eterministic finite automata (DFAs), an various transformations among the previously liste formalisms. The final prouct of the theory towars practical implementation is a DFA. CPU Core L1 Cache L2 Cache RAM usage. Section 3 then escribes general techniques for DFA implementation. It is mostly suitable for DFA that is run most of the time. Since DFA has a finite set of states, this kin of DFA has to have cycles. Recent results in the implementation using CPU cache are iscusse in Section. On the other han we have a collection of DFAs each representing some ocument (e.g., in the form of complete inex in case of factor or suffix automata). Such DFA is use only when properties of the corresponing ocument are examine. Such automaton usually oes not have cycles. There are ifferent requirements for implementation of such DFA. Suitable implementations are escribe in Section 5. 2 Noneterministic finite automaton Noneterministic finite automaton (NFA)isaquintuple(Q,,, q 0, F), where Q is a finite set of states, is a set of input symbols, is a mapping Q ( ) ( Q), q0 Q is an initial state, an F Q is a set of final states. Deterministic finite automaton (DFA) is a special case of NFA, where is a mapping Q Q. a b c Fig. 1: Memory Cache Hierarchy DFA then runs theoretically in time (n), where n is the size of the input text. However, in practice we have to consier CPU cache that rapily influences the spee. CPU has two level caches isplaye in Fig. 1. The level 1 (L1) cache is locate on chip. It takes about 2 3 CPU cycles to access ata in L1 cache. The level 2 (L2) cache may be on chip or may be external. It has about 10 cycles access time. The main memory access takes cycles an har isc rive access takes even 10 6 times more time. Therefore it is obvious that CPU cache significantly influences DFA run. We cannot control the CPU cache use irectly, but knowing the CPU cache strategieswecanimplementthedfaruninawaysothat CPU cache woul be most likely efficiently use. We istinguish two kins of use of DFA. For each of them we escribe the most suitable implementation. In Section 2 we efine noneterministic finite automaton an iscuss its Fig. 2: A eterministic finite automaton In the previous efinition we talk about completely efine DFA, where there is for each source state an each input symbol exactly one estination state efine. However, there is also partially efine DFA, where there is for each source state an each input symbol at most one estination state efine. The partially efine DFA can be transforme to completely efine DFA introucing a new state (so calle sink state) which has a self loop for each symbol of an into which all non efine transitions of all states lea. There are also NFAs with more than one initial state. Such NFAs can be transforme to NFAs with one initial state introucing a new initial state from which transitions lea to all former initial states. Czech Technical University Publishing House 51 c

2 NFA accepts a given input string w * if there exists a path (a sequence of transitions) from the initial state to a final state spelling w. The problem occurs when for a pair (q, a), q Q, a (i.e., state q of NFA is active an a in the current input symbol) there are more possibilities how to continue: 1. There are more than one transitions labele by a outgoing from state q. Thatis ( qa, ) Thereisan transition in aition to other transitions outgoing from the same state. In such a case NFA cannot ecie, having only the knowlege of the current state an current input symbol, which transition to take. Due to this noneterminism NFA cannot be irectly use. There are two options: 1. We can transform NFA to the equivalent DFA using the stanar subset construction [21]. However, it may lea to an exponential increase of number of states (2 Q NFA states, where Q NFA is the number of states of the original NFA). The resulting DFA then runs in linear time with respect to the size of the input text. 2. We can simulate the run of NFA in a eterministic way. We can use Basic Simulation Metho [7, 6] usable for any NFA. For NFA with a regular structure (like in the exact an approximate pattern matching fiel) we can use Bit Parallelism [16,7,6,10] or Dynamic Programming [16, 8, 6] simulation methos which improve the running time of the Basic Simulation Metho in this special case. The simulation runs slower than DFA however the memory requirements are much smaller. Practical experiments weregivenin[11]. 3 Deterministic finite automaton implementation Further in the text we o not consier simulation techniques. We consier only DFA. DFA runs theoretically in time ( n ),wheren is the size of the input text. There are two main techniques for implementation of DFA: 1. Table Driven (TD): The mapping is implemente as a transition matrix of size Q (transition table). The current state number is hel in a variable q curr an the next state number is retrieve from the transitiontable from line q curr an column a,wherea is the current input symbol. 2. Har Coe (HC) [22]: The transition table is represente as a programming language coe. For each state there is a place starting with a statelabel. Then there is a sequence of conitional jumps, where base on the current input symbol the corresponing goto comman to the estination statelabel is performe. 3.1 Table Driven An example of TD implementation is shown in Fig. 3. For partially efine DFA one have to either transform it to a completely efine DFA or hanle the case when a unefine transition shoul be use. Obviously TD implementation is very efficient for completely efine DFA or DFAs with nonsparse transition table. It can be also very efficiently use in programs, where DFA is constructefromagiveninputanthenitisrun.insucha case it can be easily store into the transition matrix. The coe for the DFA run is then inepenent on the content of the transition matrix. TD implementation is also very convenient for a harware implementation, where the transition matrix is represente by a memory chip. 3.2 Har Coe An example of HC implementation is shown in Fig.. The implementation can work with partially efine DFA in this case. HC implementation may save some space when use for partially efine DFA, where the transition matrix woul be sparse. It cannot be use in programs, where DFA is constructe from the input. When DFA is constructe, a har coe part of the program has to be generate in a programming language, then compile an execute. This technique woul nee calls of several programs (compiler, linker, the DFA program itself) an woul be very inefficient. Note that we cannot use the recursive escent [1] approach from LL(k) topown parsing, where each state coul be represente by a function calling recursively a function representing the following state. In such a case the system stack woul overflow since DFA woul return from the function calls only at the en of the run. There woul be as many neste function calls as the size of the input text. However, Ngassam s implementation [18] uses a function for each state, but the function (with the current input symbol given as a parameter) returns an inex of the next state an then the next state function (with the next input symbol given as a parameter) is calle. transition_table: a b c int DFA_TD(){ int state=0,symbol; while((symbol= getchar())!= EOF ) { state = transition_table[state][symbol]; returnis_final[state]; Fig. 3: Table Driven implementation of DFA from Fig Czech Technical University Publishing House

3 int DFA_HC(){ int symbol; state0:if ((symbol= getchar())== EOF) return0; case a : goto state1; case : goto state; efault:return(1); state1:if ((symbol= getchar())== EOF) return0; case b : goto state2; case c : goto state3; efault:return(1); state2:if ((symbol= getchar())== EOF) return0; case c : goto state3; case : goto state; efault:return(1); state3:if ((symbol= getchar())== EOF) return0; case : goto state; efault:return(1); state:if ((symbol= getchar())== EOF) return1; return(1); Fig. : Har Coe implementation of DFA from Figure 2 DFA with cycles TD an HC implementations (an their combination calle MixeMoe MM) were heavily examine by Ngassam [20, 18]. His implementations use a ata structure that most likely will be store in CPU cache. For each of TD an HC implementationshe evelope three strategies to use CPU cache efficiently: Dynamic State Allocation (DSA), State pre orering (SpO), an Allocate Virtual Caching (AVC). DSA strategy has been suggeste in [19] an was prove to outperform TD when a largescale DFA is use to recognize very long strings that ten to repeately visit the same set of states. SpO relies on a egree of prior knowlege about the orerin which states are likely to be visite at runtime. It was shown that the associate algorithm outperforms its TD counterpart no matter the kin of string being processe. AVC strategy reorers the transition table at run time an also leas to better performance when processing strings that visit a limite number of states. Ngassam s approach can be efficiently exploite in DFA, where some states are frequently visite (like in DFA with cycles). In both TD an HC Ngassam s implementations the transition table is expecte to have the same number of items in each row (i.e., each state having the same number of outgoing transitions). Ngassam s implementation uses a fixe size structure for each row of the transition table. Therefore for sparse transition matrix the metho is not so memory efficient. 5 Acyclic DFA Another approach is use for acyclic DFA. In these automata each state is visite just once uring the DFA run. Suffix automaton an factor automaton (automaton recognizing all suffixes an factors of the given string, respectively) [3, ] are of such kin. Given a pattern they verify if the pattern is a suffix or a factor of the original string in time linear with the length of pattern regarless the size of the original string. An efficient implementation of the suffix automaton (also calle DAWG Direct Acyclic Wor Graph) was create by Balík [2]. An implementation of the compact version of the suffix automaton calle compact suffix automaton (also calle Compact DAWG) was presente by Crochemore an Holub in [9]. Both these implementations are very efficient in terms of memory use (about bytes per input string symbol). The factor an suffix automata are usually built over whole texts typically several megabytes long. Instea of storing the transition tableas a matrix like in TD implementation, whole automatonisuseinabitstream.thebitstreamcontainsa sequence of states each containing a list of all outgoing transitions (i.e., sparse matrix representation). Czech Technical University Publishing House 53

4 bitstream: state number: 0 a 0 b c 0 c Fig. 5: A sketch of bitstream implementation of DFA from Fig. 2 The key feature of both implementations is a topological orering of states. It ensures that we never get back in the bit stream when traversing the automaton. This minimizes main memory (or har isc rive) accesses. Balík s implementation is focuse on the smallest memory use. It uses some ata compression techniques. It also exploits the fact that both factor an suffix automata are homogeneous automata [5], where each state has all incoming transitions labele by the same symbol. Therefore the label of incoming transition is store in the estination state. The outgoing transition then only points to the estination state, where the corresponing transition label is store. On the other han Holub s implementation consiers also the spee of traversing. Each state contains all outgoing transitions together with their transition labels like in Fig. 5. (However, the DFA represente in Fig. 5 is neither suffix nor factor automaton.) It is not so memory efficient like Balík s implementation but it reuces main memory (or har isc rive) accesses. It exploits the locality of ata principle use by CPU cache. When a state isreache uring the DFA run, whole segment aroun the state is loae into CPU cache (from main memory or har isc rive). The ecision which transition to take is one base only on the information in the segment (in the CPU cache) an no other accessesto other segments (i.e., possible memory/hdd accesses) are neee. While in Balík s implementation one nees to access all the estination states to retrieve the transition labels of the corresponing transitions. Holub s implementation uses at most as many main memory/hdd accesses as many states are traverse. 6 Conclusion The paper presents two approaches to DFA implementation consiering CPU cache. The first approach is suitable for DFA with cycles where we expect some states are visite frequently. HC an TD implementations for DFA with nonsparse transition table were iscusse. On the other han the other approach is suitable for acyclic DFA with a sparse transition table. This approach saves memory use but it runs slower than the previous one instea of irect transition table access (coorinates given by the current state an the current input symbol) a linke list of outgoing transition of a given state is linearly traverse. However, reucing the memory use for the transition table increases the probability that the next state is alreay in the CPU cache which also increases the spee of DFA run. The first approach is suitable for the DFAs that are running all the time like for example an antivirus filter on a communication line. On the other han the secon approach is suitable for a collection of DFAs from which one is selecte an then it is run. That is for example a case of suffix or factor automata buil over a collection of ocuments store in har isk. The task is then for a given pattern fin all ocuments containing the pattern. Acknowlegment This research has been partially supporte by the Ministry of Eucation, Youth an Sports uner research program MSM an the Czech Science Founation as project No. 201/06/1039. References [1] Aho,A.V.,Sethi,R.,Ullman,J.D.:Compilers Principles, Techniques an Tools. AisonWesley, Reaing, MA, [2] Balík, M.: DAWG versus Suffix Array. In: J.M. Champarnau, D. Maurel (es.): Implementation an Application of Automata, number 2608 in Lecture Notes in Computer Science, p SpringerVerlag, Heielberg, [3] Blumer,A.,Blumer,J.,Ehrenfeucht,A.,Haussler,D., Chen, M. T., Seiferas, J.: The Smallest Automaton Recognizing the Subwors of a Text. Theor. Comput. Sci., Vol. 0 (1985), No. 1, p [] Blumer,A.,Blumer,J.,Ehrenfeucht,A.,Haussler,D., McConnel, R.: Complete Inverte Files for Efficient Text Retrieval an Analysis. J. Assoc. Comput. Mach., Vol. 3 (1987), No. 3, p [5] Champarnau, J.M.: Subset Construction Complexity for Homogeneous Automata, Position Automata an ZPCStructures. Theor. Comput. Sci., Vol. 267 (2001), No. 1 2, p [6] Holub, J.: Simulation of Noneterministic Finite Automata in Pattern Matching. Ph.D. Thesis, Czech Technical University in Prague, Czech Republic, [7] Holub, J.: Bit Parallelism NFA Simulation. In: B. W. Watson, D. Woo (es.): Implementation an Application of Automata, number 29 in Lecture Notes in Computer Science, p SpringerVerlag, Heielberg, [8] Holub, J.: Dynamic Programming NFA Simulation. In: J.M. Champarnau, D. Maurel (es.): Implementation an Application of Automata, number 2608 in Lecture Notes in Computer Science, p Springer Verlag, Heielberg, [9] Holub, J., Crochemore, M.: On the Implementation of Compact DAWG s. In: J.M. Champarnau, D. Maurel (es.): Implementation an Application of Automata,number 2608 in Lecture Notes in Computer Science, p SpringerVerlag, Heielberg, Czech Technical University Publishing House

5 [10] Holub, J., Iliopoulos, C. S., Melichar, B., Mouchar, L.: Distribute String Matching Using Finite Automata. In:R.Raman,J.Simpson(es.):Proceeings of the 10 th Australasian Workshop On Combinatorial Algorithms, p , Perth, WA, Australia, [11] Holub, J., Špiller, P.: Practical Experiments with NFA Simulation.In:L.Cleophas,B.W.Watson(es.):Proceeings of the Einhoven FASTAR Days 200, TU Einhoven, The Netherlans, 200, p [12] Huffman, D. A.: The Synthesis of Sequential Switching Circuits. J. Franklin Institute, Vol. 257 (195), p , [13] Kleene, S. C.: Representation of Events in Nerve Nets an Finite Automata. Automata Stuies, (1956), p [1]McCulloch,W.S.,Pitts,W.:ALogicalCalculusofthe Ieas Immanent in Nervous Activity. Bull. Math. Biophysics, Vol.5 (193), p [15] Mealy, G. H.: A Metho for Synthetizing Sequential Circuits. Bell System Technical J., Vol. 3 (1955), No. 5, p [16] Melichar, B.: Approximate String Matching by Finite Automata. In: V. Hlaváč, R. Šára (es.): Computer Analysis of Images an Patterns, number 970 in Lecture Notes in Computer Science, p SpringerVerlag, Berlin, [17] Moore, E. F.: Geanken Experiments on Sequential Machines. Automata Stuies, 1956, p [18] Ngassam, E. K.: Towars Cache Optimization in Finite Automata Implementations. Ph.D. Thesis, University of Pretoria, South Africa, [19] Ngassam, E. K., Kourie, D. G., Watson, B. W.: Reorering Finite Automatata States for Fast String Recognition. In:J.Holub,M.Šimánek(es.):Proceeings of the Prague Stringology Conference 05, Czech Technical University in Prague, Czech Republic, 2005, p [20] Ngassam, E. K., Kourie, D. G., Watson, B. W.: On Implementation an Performance of TableDriven DFA Base String Processors. In: J. Holub, J. Ž árek (es.): Proceeings of the Prague Stringology Conference 06, Czech Technical University in Prague, Czech Republic, 2006, p [21] Rabin, M. O., Scott, D.: Finite Automata an Their Decision Problems. IBM J. Res. Dev., Vol. 3 (1959), p [22] Thompson, K.: Regular Expression Search Algorithm. Commun. Assoc. Comput. Mach., Vol. 11 (1968), p Ing. Jan Holub, Ph.D. holub@fel.cvut.cz Department of Computer Science an Engineering Czech Technical University in Prague Faculty of Electrical Engineering Karlovo nám Prague 2, Czech Republic Czech Technical University Publishing House 55