scispace - formally typeset
Search or ask a question
Journal ArticleDOI

Performance analysis of a message-oriented knowledge-base

01 Jul 1990-IEEE Transactions on Computers (IEEE Computer Society)-Vol. 39, Iss: 7, pp 951-957
TL;DR: A message-driven model for function-free Horn logic is presented, where the knowledge base is represented as a network of logical processing elements communicating with one another exclusively through messages.
Abstract: A message-driven model for function-free Horn logic is presented, where the knowledge base is represented as a network of logical processing elements communicating with one another exclusively through messages. The lack of centralized control and centralized memory makes this model suitable for implementation on highly parallel asynchronous computer architecture. The performance of this message-driven system is analyzed and compared to that of a sequential resolution scheme using backtracking. Closed-form expressions for both approaches are derived. >

Summary (3 min read)

1. Introduction

  • In section 5, the authors analyze the performance of the Horn knowledge-base system that uses backtracking.
  • In section 7, the numerical results are shown, and performance of their deductive model is compared with that of the Horn knowledge-base with a backtracking mechanism.

3. The Message-Driven Knowledge-Base Model

  • The authors message-driven knowledge-base model follows the same conventions as the first-order function-free Horn knowledge-base described in section 2 but is capable of exploiting parallel processing.
  • Queries from the users are processed by the query processors at Layer 3.
  • The other set comprises all inference rules and is called the Intensional Database (IDB).
  • The machine may contain a large number of processing elements (PEs) without any central controller.
  • These PEs can communicate with one another asynchronously via messages.

3.1. The Extensional Database (EDB)

  • The authors data model can be easily described by the function-free binary logic in which the predicate names are arcs and terms are set nodes.
  • In the predicate belong(employee, dept), the relation belong is the predicate name and the sets employee and dept are the terms.
  • The authors assume only binary predicates in their data model.
  • There are three reasons to use binary predicates rather than nary predicates.
  • Third, the authors can represent "missing" data better than with an n-ary predicate.

3.2. The Intensional Database (1 DB)

  • The rectangles of the graph represent the virtual relations.
  • The definitions of these virtual relations (e.g. the bodies of the rules) form a tree in which nodes are terms and edges are predicate names.
  • Since the rules in the IDB will share the structures of some base relations (for instance, the virtual relations boss and immediate_boss share the base relation supervisor), the authors need to separate them from tangling with one another.
  • The virtual relation immediate_boss has color b.
  • If a message is injected into the node immediate_boss(X, Y), only those arcs marked with color b will allow the message to go through.

3.3. Inference Engine -Message Propagation Scheme for SL-Resolution

  • The way that messages are being propagated in both IDB and EDB corresponds to the left-to-right SL-resolution described in section 2.
  • These two messages are then injected to the node alex in the EDB.

5.1. Case 1: The Number of Correct Answers Is Known

  • The authors assume the number of correct answers is known and examine how well the backtracking model behaves.
  • The major characteristic of this case lies in the search termination condition: whenever the foreknown number of answers are retrieved, the search is terminated.
  • Therefore, the tree does not have to be completely searched.
  • Since the authors have knowledge on both the proof tree and the number of correct answers, the possible assignments of these answers to the leaves are known.
  • With these assignments, the authors can further obtain the average and best completion times.

(I) Average Case

  • Let iavg be the average completion time to search for all answers from the root.
  • In the first assignment Ai, the rightmost correct answer is assigned to the second leaf (i.e. p = 2).
  • At each level of the tree, the search process finds the correct branch (the leftmost branch) immediately.

6. Performance Analysis of Message-Propagation Scheme

  • If the authors assume that the number of correct answers is known, the search will be terminated as soon as the foreknown number of answers have been retrieved.
  • With the knowledge of the search tree and the number of answers, the authors are able to derive all possible assignments of answers to the leaves as described previously.
  • With these assignments, the authors can further analyze the average and best behavior of their model.

Si

  • If the authors assume that the t} and iph are constants and are equal to t f and tp, respectively, eq. 6.1.1 becomes: where P(Aj) is the probability of assignment Aj being chosen.
  • If the tree is a regular tree with depth w, branching factor b and with one answer, the best case occurs if the answer is the leftmost leaf.
  • Since, at each level, the first generated message is propagated into the correct path immediately.

7.2. Irregular Trees, Varying Number of Answers

  • For the second observation, the authors notice that, with a backtracking model, to search for an additional answer would mean to fail the currently found answer and to backtrack in order to get to the remaining branches of the tree.
  • This backtracking time (tb) is a dominant factor in determining the average completion time.
  • The authors notice that the increase in the backtracking time to find additional answers diminishes as the total number of answers increases.
  • The last observation just confirms their previous discussion in section 7 .1.

7.4. The Structure of the Knowledge-Base: Bushy vs Skinny

  • For the last observation, the authors realize that a skinny structure has fewer branches than a bushy structure.
  • Moreover, their message propagation scheme generates copies of message sequentially (as described in section 6.1 ).
  • Therefore, the time difference of generating the first and last copies of the outgoing messages is less than that in a bushy structure.

8. Concluding Remarks

  • The major components of their model are the semantic networks representation of the IDB and EDB, and the implementation of the SL-resolution by means of message propagation.
  • Since, the message propagation is done asynchronously, the resolution done in this manner is a set at a time instead of.
  • Using the backtracking method which carries out the resolution a tuple at a time.

Did you find this useful? Give us your feedback

Content maybe subject to copyright    Report

Citations
More filters
Journal ArticleDOI
TL;DR: Using Intel's iPSC/2 hypercube, the authors measured the relationship between packet size, method of clustering messages, and internode traffic on the total sustained communication bandwidth and analyzed duplicate removal algorithms.
Abstract: Using Intel's iPSC/2 hypercube, the authors measured the relationship between packet size, method of clustering messages, and internode traffic on the total sustained communication bandwidth. Having measured the costs associated with internode communication, they then analyzed duplicate removal algorithms. They also studied the effects of nonuniformly distributed attribute values and tuples across processors on three proposed duplicate removal algorithms. They chose algorithms to represent the several available in the literature and then evaluated the output collection time. The authors present a brief overview of the iPSC/2's hypercube message-passing system and discuss the results of their experimentation and analysis. >

13 citations

Book ChapterDOI
01 Jan 1991
TL;DR: A space search method using an Artificial Intelligence (AI) language - Prolog, is developed and it is shown that this approach complies with the requirement of on-board fault detection circuits.
Abstract: This paper describes the application of database search techniques to simulate on-line fault detection in satellite communication systems. Conventional methods of fault detection by hardware is difficult in complex Digital Signal Processing (DSP) circuits which handle real-time data. Hence, a space search method using an Artificial Intelligence (AI) language - Prolog, is developed and it is shown that this approach complies with the requirement of on-board fault detection circuits. Application of the space search method to two key elements in DSP circuits - the multiplier and Adder/Subtractor is described. Implementation of such a novel fault detection method on-board a satellite, has constraints in terms of space and weight and the tradeoff needed is explained. Use of AI based search methods to analyse on-board satellite systems, are not only useful for fault detection but also for other diagnostic jobs in satellites.

2 citations

References
More filters
Journal ArticleDOI
TL;DR: By regarding semantic networks as an abstract data structure for the representation of clauses, this work provides a theorem-prover with a potentially useful indexing scheme and path-following strategy for guiding the search for a proof.
Abstract: An extended form of semantic network is defined, which can be regarded as a syntactic variant of the clausal form of logic. By virtue of its relationship with logic, the extended semantic network is provided with a precise semantics, inference rules, and a procedural interpretation. On the other hand, by regarding semantic networks as an abstract data structure for the representation of clauses, we provide a theorem-prover with a potentially useful indexing scheme and path-following strategy for guiding the search for a proof.

95 citations

01 Jan 1986
TL;DR: This dissertation addresses the problems of database architecture design, query processing, concurrency control, and recovery for a memory resident relational database, an environment with a very different set of costs and priorities.
Abstract: Most previous work in the area of main memory database systems has focused on the problem of developing techniques that work well with a very large buffer pool This dissertation addresses the problems of database architecture design, query processing, concurrency control, and recovery for a memory resident relational database, an environment with a very different set of costs and priorities An architecture for a memory-resident database system is presented, along with a discussion of the differences between memory-resident database systems and conventional disk-based database systems Index structures are then studied for a memory-resident database environment The T Tree, a new index structure designed for use in this environment, is introduced and compared with several existing index structures: Arrays, AVL Trees, B Trees, Extendible Hashing, Linear Hashing, Modified Linear Hashing and Chained Bucket Hashing The T Tree is shown to perform well in a memory-resident environment Several of the index structures are then used to examine relational join and projection algorithms for a main memory database environment Experimental results show that a Merge Join algorithm that uses a T Tree index is usually the best method, and that a simple Hash Join algorithm is usually second best Recovering a memory-resident database is different from recovering a disk-oriented database, so a different approach is taken in this dissertation Existing proposals for memory-resident database recovery treat the database as a single entity, so recovery and checkpoint operations are applied to the entire database A new design is proposed that allows logging, checkpointing and recovery to be done at the relation or index level, providing a form of demand recovery After a crash transactions declare the relations that must be restored before they can run, with undemanded relations being recovered by a background task Finally, the cost issues for concurrency control are different for a memory-resident database system Locking is more costly on a per database access basis, so it must be made more efficient Multiple granularity locking is desirable, but it would be too expensive if several levels of locks needed checking for every database reference An algorithm is presented that uses locks with a dynamic level of granularity, with locks being escalated or de-escalated in size to meet the system's concurrency requirements

36 citations

Journal ArticleDOI
TL;DR: It is demonstrated how logic programs may be converted into collections of data-flow graphs in which resolution is viewed as a process of finding matches between certain graph templates and portions of the data- flow graphs.
Abstract: There is a direct correspondence between semantic networks and a subset of logic programs, restricted only to binary predicates. The advantage of the latter is that it can describe not only the nodes and arcs comprising a semantic net, but also the data-retrieval operations applied to such nets. The main objective of this paper is to present a data-driven model of computation that permits this subset of logic programs to be executed on a highly parallel computer architecture. We demonstrate how logic programs may be converted into collections of data-flow graphs in which resolution is viewed as a process of finding matches between certain graph templates and portions of the data-flow graphs. This graph fitting process is carried out by messages propagating asynchronously through the data-flow graph; thus computation is entirely data driven, without the need for any centralized control and centralized memory. This permits a potentially large number of independent processing elements to cooperate in solving a given query.

23 citations