JP2558361B2 - Data processing system - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION [Outline] A data processing system for processing data of a logical language, in which source data of a prolog is converted into an array format and stored in a memory, and the data of the prolog is generated from this as needed. However, for the purpose of efficiently storing a large amount of Prolog data and reducing memory consumption, the Prolog source data is converted to stored data in the form of an array and stored in memory. It is configured such that only the above-mentioned stored data is taken out, prolog data is generated and stored in the memory, and the processing is performed with reference to this.

[Industrial applications]

The present invention relates to a data processing system that processes data of a logical language. Prolog language or a language based on Prolog language (hereinafter referred to as Prolog)
Is a language that allows easy and flexible description of processing such as search, generation, combination, and reconstruction of data of various data types.
Moreover, it is a logical programming language and has an inference function. Therefore, it is expected as a language for describing various systems including expert systems, search systems, knowledge base systems, and natural language analysis. At this time, handling a large amount of data consumes a large amount of memory, and thus there is a urgent need for improvement in memory efficiency.

[Conventional technology]

In the system described using the conventional prolog,
The data is stored as shown in FIGS. 6 (1), (2), and (3).

(1) Read the prolog source program into memory (Fig. 6 (1)).

(2) The object code obtained by compiling the prolog source program is read into the memory (Fig. 6 (2)).

(3) Using the built-in predicate of the prolog, it is directly registered in the memory using the key (Fig. 6 (3)).

[Problems to be Solved by the Invention]

Since (1) and (3) above have all data in memory in prolog format, (2) reads the code corresponding to all processing such as unification for all data into memory, so memory efficiency is improved. There was a problem of being bad.

The present invention converts prolog source data into an array format and stores it in memory, generates prolog data from this when necessary, and efficiently stores a large amount of prolog data to reduce memory consumption. The purpose is to do.

[Means for solving the problem]

 FIG. 1 shows the principle configuration of the present invention.

In FIG. 1, stored data 2 is obtained by converting source data of prolog into an array format and storing it in a memory.

The prolog data 3 is obtained by taking out the necessary stored data 2 when necessary, generating it as prolog data, and storing it in the memory.

[Action]

As shown in FIG. 1, the present invention converts prolog source data into storage data 2 in the form of an array and stores it in a memory. When necessary, only the necessary storage data 2 is extracted and the prolog data 4 is stored. Is generated and stored in the memory, and the process is performed by referring to the prolog data 4.

Therefore, by converting the source data of the prolog into the storage data 2 of the array format which consumes less memory and storing it in the memory, the source data of the prolog is efficiently stored in the memory and the memory consumption is reduced. It becomes possible.

〔Example〕

Next, the configuration and operation of one embodiment of the present invention will be sequentially described in detail with reference to FIGS. 1 to 5.

 FIG. 1 shows the principle configuration of the present invention.

In FIG. 1, a prolog source 1 is source data described in prolog.

The stored data 2 is data in which the prolog source 1 is converted into an array format having good memory efficiency and stored in the memory (see FIGS. 2, 3, and 5).

The prolog data 3 is data in which only the necessary stored data 2 is taken out when needed, generated in the prolog format, and stored in the memory.

FIG. 2 shows a block diagram of an embodiment of the present invention. this is,
When the data unit is a list.

FIG. 2A shows an example of stored data (when the data unit is a list). This is the Prolog Source 1 shown on the left
2 is a schematic representation of the stored data 2 in which the data 1 and the data 2 are converted into the array format according to the present embodiment and stored in the memory (here, the array is a tree structure, and at the beginning of each array). Associate a pointer with the data). Specifically, the first element “2 *” of data 1: [2 * (1 + _N), 5]
For (1 + _N) ", the <array>(<>
Is a marker indicating that the "mathematical expression" is entered, and corresponding to this <mathematical expression>, the mathematical expression array is entered as shown in the first and second rows. For the second element "5", put "5" in the second line of the list array (described later in detail). Similarly, the data 2 is also put in the list array, the real number array, and the atom array as shown in the drawing.

As described above, it is possible to reduce the memory consumption amount (for example, reduce it to about half) by generating stored data by converting the prolog source 1 into an array format having good memory efficiency and storing the stored data in the memory. It will be possible.

FIGS. 2B and 2C show the prolog data 3.
This is a schematic representation of the prolog data 3 stored in the memory after taking out the stored data 2 of data 1 and data 2 in FIG. 2 (a) and converting it to the prolog format (the conversion procedure will be described later). ).

FIG. 3 shows a block diagram of an embodiment of the present invention. this is,
This is when the data unit is a tuple.

FIG. 3A shows an example of stored data (when the data unit is a tuple). This is the Prolog Source 1 shown on the left
2 schematically shows the stored data stored in the memory after being converted into the array format of data 1 and data 2 according to this embodiment.

3B and 3C show the prolog data 3.
This is a schematic representation of the prolog data 3 stored in the memory, which is obtained by converting the stored data 2 of the data 1 and the data 2 in FIG. 3 (a) (the conversion procedure will be described later).

Next, a procedure for generating the prolog data 3 from the stored data 2 will be described according to the order shown in the flowchart of FIG.

In FIG. 4, a pointer is placed at the beginning of each array. For example, the pointer is placed at the head (first line) of the list array of the storage data 2 of the data 1 of FIG.

Retrieves element X from the base array and updates the pointer. This is because the first element X "<mathematical formula>" of the list array (the pointer indicating the base array is attached when converted to the array format described above) which is the base array in FIG. To the next "5".

Determines whether the element X is a mathematical expression marker. If YES, do If no, do. Since the first element X “<expression>” in FIG. 2A is YES, the following is performed.

Retrieves the element from the formula array and updates the pointer. This is because in the case of the first element X "<mathematical expression>" in Fig. 2 (a), the elements "<*>, 2, <mathematical expression>" from the first line of the mathematical expression array in Fig. 2 (a). , And advance the pointer to the next.

Retrieves operator information and generates data. This is because the operator "*" is extracted from the elements "<*>, 2, <math>" in the first line of the mathematical expression array in Fig. 2 (a), and the prolog of this operator "*" Generate data.

Takes the argument information and creates data. This takes out the first argument "2" from the element "<*>, 2, <mathematical expression>" on the first line of the mathematical expression array shown in Fig. 2A, and generates prolog data. Also, a mathematical expression tuple is generated from the second argument “<mathematical expression>”, and the element “<+>” on the second line of the mathematical expression array in FIG.
1. Set the operator "+" of <variable>, argument "1", and "variable".

Generates a mathematical tuple and sets operators and arguments. This sets the prolog data generated in step 2 from the elements "<*>, 2, <math>" in the first row of the mathematical expression array of Fig. 2 (a), which is set in the mathematical tuple.

 Sets the element to the cons.

By the above procedure, for example, the data 1 of the stored data 2 in FIG. 2A is taken out, and the portion surrounded by the dotted line in the list of the prolog data 3 in FIG. 2B is generated.

Determines from the element X whether or not it is a label marker. This is, for example, the element X of the base array of the storage data 2 in FIG.
Is a label marker (a numerical value representing a label array). In case of YES, the argument information is taken out with, the data is generated, the label tuple is generated with, the argument is set,
Set the element in the cons with. In the case of NO, the list cons is generated with and the element is set in the cons. Then, both processes are repeated for the number of elements.

By the above procedure, for example, the data 1 and the data 2 which are the stored data 2 in FIG. 2A are sequentially taken out, and the prolog data 3 in FIG. 2B and FIG. 2C are generated. . Similarly, the prolog data 3 is also generated from the data 1 and the data 2 which are the storage data 2 in FIG.

Next, a procedure for sequentially taking out the data 1 which is the stored data 2 in FIG. 2A and generating the prolog data 3 in FIG. 2B will be described in detail.

: Take out the stored data corresponding to the data 1 and put the pointer at the beginning of each array (list array, formula array).

: Take out the first element "<mathematical formula>" of the list array and advance the pointer to the second element.

: Since the fetched element is “<math>”, the equation tuple is generated by referring to the equation array.

<Formula tuple generation process>: The elements “<*>, 2, <formula>” pointed by the pointer of the formula array are taken out, and the pointer is advanced.

: Take out the operator “*” from “<*>, 2, <mathematical expression>” and convert it into prolog data.

: Take the first argument "2" and convert it to prolog data.

: Since it is the second argument “<expression>”, the expression array is referenced and the expression tuple is generated.

<Formula Tuple Generation Processing>: The elements “<+>, 1, <variable>” pointed to by the pointer of the formula array are taken out and the pointer is advanced to the next.

: Take out the operator "+" from "<+>, 1, <variable>" and convert it into prolog data.

:: Take the first argument "1" and convert it to prolog data.

: Initialization or unification is performed because it is the second argument "<variable>".

: Generate a tuple of formula and set operator and argument data.

: Generate a tuple of formula and set data of operator and argument.

: Generate a list cons and set element data (mathematical tuple) in the CAR part.

: Take the next element "5" from the list array and advance the pointer to the next.

: Prolog data is generated because the retrieved element "5" is an integer.

: Generate a list cons and CAR the element data "5"
Set to the department.

: There are no more elements in the list, so data generation ends.

FIG. 5 shows a block diagram of an embodiment of the present invention. this is,
The stored data 2 in the case where the label tuple marker and the mathematical expression tuple marker are included as shown is shown. This is also converted into the prolog data 3 in the same manner as described above with reference to FIGS. 2 and 3 if necessary.

〔The invention's effect〕

As described above, according to the present invention, the source data of the prolog is converted into the storage data 2 in the array format which consumes less memory and stored in the memory. Since the configuration in which the log data 3 is generated and the processing is performed with reference to this is adopted, it is possible to efficiently store a large amount of source data of the prolog in the memory and reduce the memory consumption amount. This makes it possible to construct a system that takes advantage of the prologue's descriptiveness, flexible data handling, and operability.

[Brief description of drawings]

FIG. 1 is a block diagram showing the principle of the present invention, FIG. 2, FIG. 3 and FIG. 5 are block diagrams showing an embodiment of the present invention, and FIG. 4 is a flow chart for generating prolog data according to the present invention. Shows an explanatory view of the prior art. In the figure, 1 is a prolog source, 2 is storage data in an array format, and 3 is prolog data.

Claims (1)

(57) [Claims] 1. A data processing system for processing data in a logic language, a storage means for storing each element of the logic data in array format data, and the storage means when a data use request is received. And a conversion means for converting each element of the array format data stored in the above into a list format data.