<?xml version="1.0" standalone="yes"?>
<Paper uid="C88-2158">
  <Title>Object-Oriented Parallel Parsing for Context-Free Grammars</Title>
  <Section position="6" start_page="776" end_page="777" type="concl">
    <SectionTitle>
4 Analysis and Discussion
</SectionTitle>
    <Paragraph position="0"/>
    <Section position="1" start_page="776" end_page="776" type="sub_section">
      <SectionTitle>
4.1 Implementation and Experiment
</SectionTitle>
      <Paragraph position="0"> Our parsing scheme has been implemented using an object-oriented concurrent language ABCL/1. In this implementation, each computing agent in the network is represented as an ABCL/1 object which becomes active when it receive a message~ and data forms containing partial parse trees are represented as messages that are passed around by objects.</Paragraph>
      <Paragraph position="1"> The parsing program written in ABCL/1 runs on a standard single-cpu machine (e.g., Symbolics Lisp machines and Sun3s) in which parallelism is simulated by time-slicing.</Paragraph>
      <Paragraph position="2"> (The code for a simplified version of this program and sample session are given in /Yonezawa87a/.) Using this prc~ gram, we have been conducting an experiment of our proposed parsing scheme for a context-free English grammar  they are typically: 10 - 30 in length, and 10 - 20 in height (the height of a correct parse tree).</Paragraph>
    </Section>
    <Section position="2" start_page="776" end_page="777" type="sub_section">
      <SectionTitle>
4.2 The Number of Computing Agents (Objects)
</SectionTitle>
      <Paragraph position="0"> As is obvious from the construction of the network, the number of computing agents is exactly the same as that of the nodes of the network. Since the node set of the network has one-to-one correspondence to the set of symbol occurrences in a given set of grammar rules, the nmnber of computing agents can be very large if the grammar is complex.</Paragraph>
      <Paragraph position="1"> Thus the number of computing agents (i.e., objects) of the network representing the above English grammar amounts to more than 1100 (more exactly 1124 = 445+679).</Paragraph>
      <Paragraph position="2"> Of course, not all these agents can be active simultaneously. The number of all the agents that become active in processing an input string is small compared to that of the computing agents consisting of the network. Since the main task of a Type-1 agent (acting for the left symbol of a grammar rule) is just to distribute a constructed parse tree, this task Can be performed by the Type-3 agent which acts for the rightmost right symbol of the grammar rule. Thus all the Typed ag~ents can be eliminated. This reduces the number of computing agents considerably. Furthermore, there are number of other ways to reduce the number of computing agents at the sacrifice of both processing speed and the conceptual clarity of the parsing scheme. (We, however, believe that maturity of the technology for exploitation of parallelism will dispel the apprehensions regarding the number of computing agents.)</Paragraph>
    </Section>
    <Section position="3" start_page="777" end_page="777" type="sub_section">
      <SectionTitle>
4.3 Performance Analysis by Distributed Event
Simulation
</SectionTitle>
      <Paragraph position="0"> We are interested in the performance of our parsing scheme in the case where the scheme is implemented on a parallal architecture which allocates a single processor for each computing agent (i.e., object) in the network. Since it is not much interesting to theoretically analyze the complexity of our parsing scheme, we have conducted simulation.</Paragraph>
      <Paragraph position="1"> The simulation has been done by using a distributed event simulation technique. The very parsing program written in ABCL/1 was reused and slightly modified to form our distributed simulation program. As we mentioned above, the Original parsing program is written in such a way that each computing agent in the network is represetnted by a concurrently executable object which becomes active when it receives a message. The simulation program preserves the original network structure of objects (i.e., computing agents in the scheme) of the parsing program. The only modifications made to the original parsing program are: * each object keeps its local time, * each message passed around by objects additionally contains a time stamp indicating the time of the message transmission measured at the local time of the object which sent the message, * each object sends anti-messages~Jefferson85/when it receives a message containing a time stamp indicating an earlier time than the current local time of the object, and * accordingly, each object can handle an anti-message which requests to cancel the effects made by the original message.</Paragraph>
      <Paragraph position="2"> The initial result of our simulation is that the first complete parse tree is produced from the network in 0(n.h) time, measuring from the beginning of feeding an input string to the network, where n is the length of the input string and h is the height of the parse tree (not the height of. the network). This result was obtained for the context-free English grammar mentioned in Section 4.1. In this simulation we assumed that both processing of a partial parse tree by a single object (i.e., a single computing agent) and a message transmission between two objects (i.e., two computing agents) take a single unit time.</Paragraph>
      <Paragraph position="3"> Since all the possible complete parse trees for a given input string are produced from the network in the pipe-lining manner, the second and subsequent complete trees are expected to be produced in a short interval one by one. We have not yet analyzed the simulation results for these parse trees.</Paragraph>
    </Section>
    <Section position="4" start_page="777" end_page="777" type="sub_section">
      <SectionTitle>
4.4 Generality of the Parsing Scheme
</SectionTitle>
      <Paragraph position="0"> Our parsing scheme can handle the most general class of context free grammars except cyclic grammars. If a set of grammar rules has circularity 9, infinite message passing may take place in the network. To detect or avoid such infinite message passing~ a special provision must be made. But fortunately such a provision can be done at the time of compiling the set of grammar rules into the corresponding network of computing agents. As suggested in 2A simple example of circular rules is: 1 --&gt; B, B --) A, B --&gt; C.</Paragraph>
      <Paragraph position="1"> Subsection 2.2 and Figure 2, left-recursive grammar rules can be handled without any modification to the grammar rules. However, from the nature of bottom-up parsing, our parsing scheme cannot handle an e-rule (a rule that produces a null string). But ms is well known/Hopcroft79/, all the e-rules can be eliminated from a given set of grammar rules by transforming the set of rules without changing the generative power of the original set of rules. 3 It should be noted that our scheme can be extended to cope with context-sensitive grammars (or more expressive ones).</Paragraph>
    </Section>
    <Section position="5" start_page="777" end_page="777" type="sub_section">
      <SectionTitle>
4.5 Previous Work
</SectionTitle>
      <Paragraph position="0"> R.M. Kaplan advocated in /Kaplan73/ that natural language parsing should be conceptualized and implemented as a collection of asyncbronous communicating parallel processes. Our work is basically along his line, but our algorithm is completely different from his and is based on finer grain and more massive parallelism than his idea illustrated</Paragraph>
    </Section>
  </Section>
class="xml-element"></Paper>