To provide an efficient parser for natural lan­guage sentences, a parallel parsing algorithm is desirable. As Tomita's algorithm is com­patible with parallel processing, we can eas­ily develop a parallel generalized LR parser [Tanaka 89]. However, with respect to the per­formance of the parallel parsing, one of the defects of Tomita's algorithm is that it forces many parsing processes to synchronize on each shift action for the same input word. A pars­ing process that has completed a shift action must wait until all other processes have com­pleted their shift actions as well; such a synchronization strategy reduces the performance of parallel parsing.

In this paper, we will present a new parallel parsing algorithm which is a natural extension of Tomita's [Tomita 86]. Our algorithm can achieve greater performance in parallel pars­ing for natural language sentences.

There are two major differences between Tomita's algorithm and ours. Initially, the new algorithm does not make parsing pro­cesses wait for shift actions to merge many stacks with the same top state. The process that has finished a 'shift N' action first can proceed to the next actions until a reduce ac­tion needs to pop the element 'N' from the stack. If some other parsing processes carry out the same 'shift N' actions, their stacks will be merged into the position in which the first process has placed an element by the 'shift N' action.

Secondly, to avoid duplications of parsing processes the new algorithm employs Tree Structured Stacks (TSS) instead of Graph Structured Stacks (GSS). The reason why we do not use GSS is because it is rather compli­cated to implement the GSS data structure in the framework of a parallel logic programming language such as GHC. The merge operation of the stacks is realized by a GIIC stream com­munication mechanism.

In section 2 we explain generalized LR pars­ing, in section 3 give a brief introduction to GHC, and in section 4 decribe our new parallel generalized LR parsing algotihm. In section 5 we compare the parallel parsing performance of our algorithm with Tomita's.

The execution of the generalized LR algorithm is controlled by an LR parsing table generated from predetermined grammar rules. Figure 1 shows an ambiguous English grammar struc­ture, and Figure 2 an LR parsing table gener­ated from Figure 1.

Action table entries are determined by a parser's state (the row of the table) and a look-ahead preterminal (the column of the ta­ble) of an input sentence. There are two kinds of stack operations: shift and reduce opera­tions. Some entries in the LR table contain more than two operations and are thus in con­flict. In such cases, a parser must conduct more than two operations simultaneously.

The symbol 'sh N' in some entries indicates that the generalized LR parser has to push a look-ahead preterminal on the LR stack and go to 'state N'. The symbol 're N' means that the generalized LR parser has to reduce from the top of the stack the number of elements equivalent to that of the right-hand side of the rule numbered 'N'. The symbol 'acc' means that the generalized LR parser has success­fully completed parsing. If an entry contains no operation, the generalized LR parser will detect an error.

The right-hand table entry indicates which state the parser should enter after a reduce op­eration. The LR table shown in Figure 2 has two conflicts at state 11 (row no. 11) and state

NP, VP. S, PP. NP, PP. det, noun, pron. v, NP. p, NP.

Fig.l: An Ambiguous English Grammar 12 for the 'p' column. Each of the conflicting two entries contains a shift and a reduce opera­tion and is called a shift-reduce conflict. When a parser encounters a conflict, it cannot deter­mine which operation should be carried out first. In our parser, conflicts will be resolved using a parallel processing technique such that the order of the operations in conflict is of no concern.

Before explaining the details of our algorithm, we will give a brief introduction to GHC, typ­ical statements of which are given in Figure 3. Roughly speaking, the vertical bar in a GHC statement (Fig.3) functions as a cut symbol of Prolog. When goal 'a' is executed, a process of statement (1) is activated and the body be­comes a new goal in which 'b(Stream)' and 'c(Stream)' are executed simultaneously. In GHC, this is called AND-parallel execution. In other words, subprocesses 'b(Stream)' and

Fig.2: A LR Parsing Table obtained from Fig.l Grammar 'c (Stream)' are created by a parent process 'a' and they run in parallel. Note that the definition of process 'c' in statement (3) is going to instantiate the variable 'Stream' in 'c(Stream)' with '[A | Streaml]'. In such a case the execution of process 'c' will be sus­pended until 'Stream' has been instantiated by process 'b(Stream)'. By the recursive process call in the body of definition (2), process 'b' continues to produce the atom 'x' and places it on stream. The atom 'x' is sent to process V by the GHC stream communication; process V,' continues to consume atom 'x' on stream.

b(Stream), c(Stream).

Stream=[ xI Rest ], b(Rest).

c(Streaml).

Fig.3: Typical Statement of GHC

The new parallel parsing algorithm is a natural extension of Tomita's algorithm [Tomita 86] and enables us to achieve greater parallel performance. In our algorithm, if a parsing sentence contains syntactic ambigui­ties, two or more parsing processes will run in parallel.

In this section, we will show by way of a simple example that our algorithm has greater paral­lel parsing performance than Tomita's origi­nal algorithm. Consider the parallel parsing of the input sentence " I open the door with a key ", using a grammar in Figure 1 and a table in Figure 2. As the input sentence has two syntactic ambiguities, the parsing process encounters a shift-reduce conflict of the LR ta­ble and is broken down into two subprocesses. Figure 7 shows the state of the parsing process and grammatical symbols which are put into a stack. When the process has the state 12 and the look-ahead preterminal 'p', the pro­cess encounters a 'sh 6/re 6' conflict. Then it is broken down into two subprocesses: the first process performs the 'sh 6' operation and goes to state 6, and the other performs the 're 6' operation. The second process also goes to the state 6 after performing 'goto 9','re 1','goto 3', and 'sh 6' operations. The processes that run according to the simple parallel LR parsing algorithm are shown in Figure 7(a).

We can see that the two processes perform the same operations after performing the 'sh 6' operations. If we do not merge these kinds of processes, we will face an explosion in the number of processes. Tomita's algorithm ( shown in Figure 7(b) ) can avoid the duplica­tion of parsing processes by merging them into one process. However, the algorithm needs a synchronization that decreases the number of processes which are able to run in parallel. On the other hand, our algorithm ( shown in Figure 7(c) ) does not require such synchro­nization as long as these processes do not try to reduce the incomplete part of a stack. In this example, two processes run in parallel af­ter a 'sh 6/re 6' conflict has occurred. Then, an incomplete stack like [6 ,p I Tail] is cre­ated, with the upper process in Figure 7(c)

Shift Action (^) Reduce & Goto Action

Fig.7(b): A Parallel Parsing Guided by Tomita's Algorithm Fig.7(c): Our Parallel Parsing

performing the 'sh 1', 'sh 5', and 're 4' stack operations while the lower process calculates its incomplete part. After finishing the 'sh 6' operation of the lower process, the incomplete part 'Tail' will be instantiated and thus we obtain the following tree structured stack:

It is remarkable that our algorithm takes less time to than either the simple algorithm or Tomita's to generate the first result of parsing. The reason is that our algorithm can analyze two or more positions of an input sentence in parallel, which is a merit when parsing with incomplete stacks.

The complexity of our algorithm is identical to that of Tomita's [Johnson 89]. The only difference between the two is the number of processes that run in parallel. So if we sim­ulate the parsing of our algorithm and that of Tomita's on a single processor, the time of parsing will be exactly the same.

We have described a new parallel general­ized LR parsing algorithm which enables us to achieve greater performance of parallel pars­ing than Tomita's algorithm. Simulations in­dicate that most processes run in parallel and that the number of suspended processes is very small, but the experiment must be carried out using many processors. Fortunately, ICOT (headquarters of the Japanese fifth generation project) has offered us the possibility of using the Multi-PSI machine composed of 64 proces­sors. We are now preparing to conduct such an experiment to put our new parsing algorithm to the test.