JPS61115138A - Copying method of data structure of list format in program - Google Patents

Abstract

PURPOSE:To improve the recording efficiency and performance by equipping a tag for showing that a variable is included in a data structure and that for showing that a variable is excluded in the data structure and discriminating the data structure without a variable. CONSTITUTION:A source program stated at a prologue is compiled and stored in a code area (CODE) in a memory M in a table format. An interpreter reads the CODE for accumulating a result outputted from the compiler to execute the prologue and uses a copy area (COPY) for copying a list, etc., such as a stack area (STK) and a structure as a work area at the time of executing a program. An area in the memory M is used for the STK and COPY. In addition to the interpreter system that an interpreter reads and executes the result converted into a table format, such a compiler system can be applicable that a compiler generates directly a machine language and executes it. Thus factors on a list followed by a variable appearing latest need not be copied, whereby memory capacity and the number of memory access circuits can be reduced.

Description

[Detailed Description of the Invention] [Field of Application of the Invention] The present invention relates to a method for processing a predicate logical programming language based on a derivation principle such as a prologue (PLOLOG), and in particular to a structure of a list-format data structure that appears in a program. Concerning copying methods.

[Background of the invention]

In language systems, such as FORTRAN, in which programming is mainly written using external procedures, procedures and data are handled separately. On the other hand, P
In a programming language using predicate logic based on a derivation principle such as LOLOG, processing proceeds by evaluating the data itself.

Rise to PLOLOG, for example, rW, F.

(::tocks in C,S, Me l l i
Sh co-author Springer-Verlag Berli
n ) (Eldelberg Qemany (1981
) is described in detail in J.

PLOLOG is executed by unification and bank track. In this processing system, for example,
rD, H, D Warren station, ■mp 1
ement a-ting Plog-Com
piling PredicateLogtc pr
ograms, voz 1,2, DAI Re5ea
rchRel) Ort, A39.40. Univer
City of Edinburgh (1977) J.

FIGS. 2 and 3 show an example of a program written in PLOLOG. Figure 2 shows the definition of ancestor. Here, capital letters x, y, z indicate variables. The program consists of a right side and a left side separated by the symbol ``'' knee, and the relationship is such that when the right side holds true, the left side holds true. In Figure 2 ■, between variable X and variable Y, there is a pare between X and Y.
If nt (parent) (right side), then X is the ances of Y
tor (ancestor) (left side).

In Figure 2 ■, the two terms Parent separated by ′, ′
(X * Z) and ancestor (Z + Y
) can be thought of as an AND condition. That is, the second
In Figure ■, X is the parent of Z, and Z is the ances of Y.
If it is tor (right side), then X is the ancestor of Y (left side).

FIG. 3 shows a program clause that includes a list-type data structure on the left side. A list-format data structure is a structure in which multiple pieces of data are linked using pointers, and is indicated by 1 ['' in Figure 3.

The part surrounded by "]", that is, the part "(e, x, d, c)" corresponds. In addition, a and g in FIG. 3 mean predicate names. Furthermore, this list is similar to the list processing language LISP, and the internal representation format of the list is described in detail in, for example, Masakazu Nakanishi, Introduction to LISP, Kindai Kagakusha, 1977J.

Variables require special consideration when they are included in a list-like data structure. Generally, one clause is called and executed from several questions, but in that case, if the clause contains a list-format data structure and the data structure contains a variable, the variable requires a separate storage area for each call.

For this reason, in the PLOLOG processing system, there is a 2fit type method for handling structures, that is, structured data. One is called the structure processing method, which is the W
This is the method adopted by the a r r e n processing system.The other is the structure copy method, which creates a copy of the entire data when a variable is included in the data waiting for the structure. .

Regarding the structure copy method, for example, "Information Processing Society of Japan,
Proceedings of the 26th National Conference, 6D-9゜pp55-56 (
1983) J.

In the conventional structure copying method, if a list-format data structure includes at least one variable, all copies of the data structure including that variable are created. Therefore, even if most of the elements of the data structure are constants, if even one variable is included, everything including those constants must be copied.

[Purpose of the invention]

An object of the present invention is to provide a structure copying method that reduces the number of parts to be copied and reduces the number of memory accesses to improve recording efficiency and performance when generating a copy of a list-format data structure. This is what we provide.

[Summary of the invention]

The present invention provides two types of pointer tags that point to a list-format data structure: a tag that indicates that a variable is included in the data structure, and a tag that indicates that the variable is not included. Use these tags properly,
The point is that data structures that do not include variables can be identified using tags.

[Embodiments of the invention]

FIG. 4 shows the prologue processing system of the present invention. The source program written in the prologue is compiled by a compiler and stored in a code area (CODE) on memory M in a table format.

The prologue is executed by an interpreter interpreting C0DE that stores the results output from the compiler. The interpreter uses a stack area (STK) and a copy area (COPY) to create copies of structures, lists, etc. as a work area when executing a program.
).

Both STK and C0PY use areas on memory M. Although this embodiment uses an interpreter method in which an interpreter interprets and executes the results converted into a table format, it can also be applied to a compiler method in which a compiler directly generates machine language and executes the machine language.

FIG. 5 shows the interpreters INTP and C0DE.

The relationship between each area of STK and C0PY is shown. Each clause of the prologue program is converted by a compiler into a tabular format called a close table CT. The name outside the parentheses in the program (in Figure 2, an
cestor, father) is called a fan lid name.The compiler collects the fan lids with the same fan lid salt on the left side of each clause and creates a procedure head table PH.
It is registered in a table called T. For sections that have a data structure in structure or list format (example in Figure 3), convert the data structure into a table format called a structure tape/L/ST, and point to the table from the CT. tie. These tables are created in C0DE by the compiler.

8T is not created in clauses that are not lists or structures (■, ■ in Figure 7).

A stack of six characters necessary for execution is created in the ST. The local stack LS stores variables that appear in the nodal circle, the control stack C8 stores control information, and the trail stack TS stores the addresses of variables set in the LS in preparation for backtracking operations. Ru.

Of course, there are other methods of dividing the stack, and the present invention can be applied to those cases as well.

C0PY is used as an area for copying the structure in C0DE and the list-format data structure ST when executing the prologue. Within this area, there are three
It also stores integers and floating point numbers of 2 bits or more. These are all connected to the LS by pointers.

Execution of the prologue is performed by the interpreter.

When the interpreter receives a question (a clause consisting of only the right-hand side and no left-hand side), the interpreter searches the C0DE table for a clause with the same funk name as the question, and finds a clause with the same fanta name. If the argument in parentheses of the clause matches the argument in the question, or if one of them is a variable, assign a value. If a portion or substitution has been made for all the arguments, the same process is executed with the right side of the clause as a new question. The above-mentioned process is called unification, and is the basic process of an interpreter. If the same fan lid name as the question does not exist, or if any of the arguments do not match, the unification will fail.

Clause q with the same 7 amphata name q for the question ``qOC'' (y, Z, a, b, c ]) Knee r
(Y).

Consider "S". Both the question and the clause have only one argument, the question's argument is the variable ""X", and the clause's argument is the variable "Y".
, @Z” is a list “(Y, Z, a.

b, c]'', it is necessary to copy the above list. Note that [] indicates a list. a, b, and c are constants (atoms).

FIG. 6 is a diagram showing the relationship between C0DE and C0PY.

In FIG. 6, each element in each table consists of a tag section indicating the data format of the element and a data section holding data. The tag "var" indicates a variable, and the tag ""atm"
indicates a constant (atom), and the tag “undf” is C0PY
Indicates an unbyte variable (a variable to which no value has been assigned yet) copied to , and the tag "1st" indicates that the element containing the tag is a pointer to a list, and the variable is included in the data structure of the list. The tag "clst" indicates that the element containing the tag is a pointer to a list, and the data structure of the list does not contain any variables.

An element of the list is formed as a pair of two cells called a Car cell and a cdr cell. Elements in the list are linked by pointers. Both car cells and cdr cells have tags, and cells that store pointers to lists have tags ``1st'' or ``clst.'' If the variable is included in the element, the tag of the pointer is "1st", and if the variable is not included in all the elements of the list linked by the pointer, the tag of the pointer is "1st". is "@elst". In the list shown in FIG. 6, variable Z is the last variable included in the list, so the Car cell of variable Z is a pointer with a "clst" tag.

In list copy processing, copying is performed up to the pointer with the above-mentioned "clst" tag, and subsequent list elements are not copied.The compiler checks the position of the variable in the list and checks if the variable is included. A tag of '1st' is added to a pointer to a list that contains variables, and a tag of 'clst' is added to a pointer to a list that does not include variables.

FIG. 1 shows a processing flow for copying a list. In process 610, the Car cell is read from C0DE, and in process 62
Write the car cell to C0PY with 0. In process 630, the car cell is read from C0DE. In process 640, the c
Determine whether the tag of the dr cell is ``clst'' and select Yl
If lil:8, the process branches to process 670, and if NO, the process branches to process 650. In process 650, the tag part determines whether the cdr cell indicates the end of the list or whether the list continues. If the list continues (the tag is 1st), the process goes to process 660; if the list does not continue, the process goes to process 660. Branches to process 680. In process 660, the tag part of the cdr cell is left as is, the data part is changed to the address of the car cell to be written next to C0PY, and the address is written to C0PY, and the process returns to process 610, thereby further copying the elements in the list. Proceed. In process 670, the read cdr cell is converted to C0PYK.
Write and exit. In process 680, the read cdr cell is written to C0PY, and the process ends.

A list structure copy method will be explained with reference to FIGS. 7 and 8.

FIGS. 7 and 8 show the relationship between the close table (CT) and the structure table (ST). Cells representing the arguments are placed in the CT in correspondence with the arguments. If the argument is a list, 8T corresponding to the list
is made.

Also, a pointer pointing to the ST is placed in a cell within the CT.

FIG. 7 shows the relationship between ST and pointers when the structure includes variables. The pointer placed in a cell in CT has a tag 1st indicating that the list pointed to by the pointer is a list containing at least one variable in an element of the list after ST. The interpreter, in the unification of the variable and the list,
st, it is recognized that a variable is included in the list, and the copy process of the list shown in FIG. 1 is performed.

FIG. 8 shows the relationship between the ST of the list and the pointer pointing to the ST when the list does not include any variables. The pointer has a tag cls indicating that the list elements after ST of the list pointed to by the pointer do not include variables.
have t. During unification, the interpreter recognizes that no variable is included in the υ list based on the tag clst, and does not copy the list.

〔Effect of the invention〕

According to the present invention, when copying a list-format data structure that includes variables, it is not necessary to copy the elements in the list after the last variable that appears, so the storage capacity can be reduced and the number of memory accesses can be reduced. was also reduced.

[Brief explanation of drawings]

Figure 1 is an example diagram of the present invention, Figures 2 and 3 are diagrams showing a specific example of a program written in a prologue, Figure 4 is a diagram of the main processing of the present invention, and Figure 5 focuses on the interpreter. FIG. 6 is an explanatory diagram of the operation, and FIG. 7 is a diagram showing the relationship between C0DE and C0PY. FIG. 8 is an explanatory diagram of beam copy. -
1'(lLre-3↑(person, Abu ■ a, TLcts
tor-(x, Y): -fLre*t(x, x), a
wes↑or(z, 工) 3rd mouth L (3 [hi, x,, d, c]): zu (X). Lower Co1 Hi

Claims (1)

[Claims] 1. When processing a predicate logical form program based on the derivation principle, which has a list-format data structure and has a configuration in which variables included in the list-format data structure are shared. In the copying method for creating a copy of the list-format data structure described above, a tag indicating whether a variable is included in the data structure is provided as a tag included in the pointer pointing to the list data structure, and A method for copying a list-format data structure in a program, in which whether or not a variable is included is checked by looking at the tag when the program is compiled, and only in the case of a tag containing a variable, the data structure at that time is copied. 2. The copying method according to claim 1, wherein the predicate logical form program based on the derivation principle is a program written in a prolope language.