JPH03164937A - Processing system for execution of logical language program - Google Patents

Abstract

PURPOSE:To restart the interrupted execution with high efficiency by providing a restart pointer for each goal. CONSTITUTION:A restart printer 13 is provided for each goal 12, and the prescribed initial value 14 is set to the pointer 13. An execution processing part 10 carries out a program 11 with the goal 12 connected to an executable goal queue. When the interruption conditions are detected, the value pointing a clause kept in a selective trial is defined as the restart address value and compared with the value held by the pointer 13. Then only when the restart address value is smaller than the value held by the pointer 13, the pointer 13 is updated with the restart address value. When the execution is restarted, the part 10 decides the clause to be carried out at first based on the address value held by the pointer 13. Then the part 10 starts the execution of the subsequent clauses only. Thus the restarted execution is carried on with high efficiency.

Description

[Detailed Description of the Invention] [Summary] Regarding execution interruption processing in executing a logic language program, a logic language program execution method that allows execution to proceed efficiently after restarting when the interrupted execution is resumed. For the purpose of processing method, a given program consisting of clauses of a predetermined logical language is executed sequentially for a required goal starting from the closing with the lowest number, and by detecting a predetermined interrupt condition, When suspending execution, a restart pointer is provided for each goal, and if the restart address value is smaller than the value held in the pointer, the pointer is updated with the restart address value, and the restart address value is The restart pointer is set in advance to a predetermined initial value, and the initial value is a value not smaller than the final address value instructing the closing. If a predetermined restart condition is satisfied for the goal, the execution is configured to restart from the close indicated by the restart pointer.

[Industrial application field]

The present invention relates to a logic language program execution processing method for handling execution interruptions in the execution of logic language programs.

[Prior art and problems to be solved by the invention] Known G
HC (Guarded 1lorn C1uses
), so-called logical language programs such as )
1i (X++・9.+X, l) Knee Gil+”'+G
11Ill Bil+"・+B,.

First, ? is represented by a set of expressions called roses, such as ? Starting with the goal o(y,...,y4) given by -H(y++...,yn), the goal and
Execution of the program occurs by attempting to unify with each close of the program.

Now, the left side of the symbol "knee" of the cloth is the head,
Each G and J on the right side is called a guard goal, and each Bi is called a body goal.

Unification is, as is well known, for each clause with a head of predicate I4 that matches the goal, the arguments yl+..., y, of the goal, and the corresponding arguments of the arguments XI+...lX11 of the clause head. When satisfies a predetermined relationship (for example, if a value is given to the goal argument that corresponds to the variable that is the argument of the clause, if the values of the corresponding stroke arguments match, etc.), then the goal and the argument of the clause are This is an operation to replace with the same value.

This unification is tried sequentially starting from the lowest numbered close in the program, and the close that succeeds in unification is selected first.Then, a similar execution is attempted with each guard goal of that close as a new goal, and the close If all guard goals are successfully executed, the program execution proceeds to the body goal execution, and so on.

In the GHC, etc., in the case of this unification,
Replacement that instantiates the goal variable with the value of the head's corresponding argument is not allowed, and if a unification attempt detects such a condition (which is considered an abort condition), the close selection is considered a failure and its Store the variables in the suspension stack and proceed to another close.

When the final number close is processed in this manner, the suspension stack is rotated eight times and if the suspension stack is empty, the execution of the goal is terminated and a predetermined action is taken. On the other hand, if one or more variables are stored in the suspension stack, the goal can be suspended, e.g. in the executable goals queue, in order to resume execution when the values of those variables are determined. Start execution for another goal.

In order to make the goal that has been interrupted as described above executable when the values of all the variables that caused the interruption have been determined, for example, as shown in Figure 4, the control block of the goal can be changed to the variable in question. The configuration hooked to waits for the required conditions to be met.

In the figure, each hook pointer 1 is set L3 corresponding to a variable, and indicates the chain for each variable of the suspension record 2 for each goal hooked to that variable.

Each suspension record 2 forms a chain with one pointer, and the other pointer points to a suspension flag record 3 corresponding to a desired goal. The suspension flag record 3 instructs the goal control block 4 of the required goal, and also displays the number of suspension records 2 that instruct itself in the variable number column, that is, the number of variables whose values are waiting for the goal to be determined. are doing. The goal control block 4 is made to hold information necessary for execution, such as information on actual arguments of the goal.

Therefore, the example in the figure is an example of a goal that is suspended waiting for the values of two variables X and Y to be determined, and when the values of those variables are determined as a result of execution for other goals, the values are The hook pointer 1 corresponding to the determined variable is separately searched, and the value of the variable is given to the goal control block 4 connected to the hook pointer 1 via the suspension record 2 and the suspension flag record 3. The number of months in the variable number field is decreased, and the goal control block 4 whose number of variables shown in the suspension flag record 3 becomes 0 is connected to the executable goal queue.

The goals that have become executable in this way are sequentially taken out of the queue, and execution resumes from the close of the beginning of the program as described above.

Therefore, in execution after restarting, the same unification attempt as the previous one will be repeated even for closes that have previously failed in selection due to factors other than the interruption factor and are determined to fail this time as well. There is a problem of wasted time.

An object of the present invention is to provide a logical language program execution processing method that can efficiently proceed with execution after restarting when interrupted execution is restarted.

[Failure to solve the problem]

FIG. 1 is a block diagram showing the configuration of the present invention.

The figure shows the configuration of a logical language program execution processing method, in which the execution processing unit 10 executes a program program 1.11 at a location Jj consisting of a predetermined logical language When executing the goal 12 sequentially from close and detecting a predetermined interruption condition, a restart pointer 13 is provided for each goal 12, and the restart address value is held in the pointer. If the restart pointer 13 is smaller than the restart address value, the restart pointer 13 is updated with the restart address value, and the restart address value is determined to instruct the closing of the execution target at the time of the interruption, and the restart pointer 13 is set in advance to a predetermined initial value. The initial value 14 is set to a value of 14, which is a value that is not smaller than the address value that instructs the final closing of the goal, and when the predetermined restart condition is satisfied for the goal I2, the restart pointer 1
Execution is resumed from the close indicated by step 3.

[Function] With this processing method, the restart pointer 13 of the interrupted goal 12 retains a value instructing the closing of the highest number among the closings that include the cause of the interruption of the goal, so that execution By starting execution from the close indicated by the restart pointer 13 at restart II, there is no need to perform redundant unification attempts for previous closes.

〔Example〕

According to the present invention, the execution processing section 10 of FIG.
As shown in the figure, a goal control block 20 provided with a restart pointer 13 is provided for each goal, and the restart pointer 13 is initially set to the initial value 14 shown in FIG.

The other contents of the goal control block 20 are the same as the previous goal control block 4. The content of the initial value 14 is an address value instructing the closing of the last number of the program 11 to be executed or a value larger than that.

When the execution processing unit 10 executes the program 11 for the goals connected to the executable goal queue as in the past and detects the same interruption condition as described above, the variable that caused the interruption, for example, the variable X, is shown in FIG. As shown, the goal control block 20 is connected from the hook pointer 1 through the suspension record 2 and the suspension flag record 3 in the conventional manner, and the number of variables in the suspension flag record 3 is increased.

Here, the value instructing the close that was being attempted at that time is set as the restart address (ffi) in the restart pointer 13.
The restart pointer 13 is updated with the value only when the restart address value is smaller than the value held by the restart address value.

As mentioned above, the initial value of the restart pointer 13 is set to a sufficiently large value that is not smaller than the address value that instructs the final close, so the address of the close where the interruption condition first occurs for a certain goal is set as the initial value. is usually smaller than the initial value, so the restart address value is set in the restart pointer 13.

However, if another interrupt condition occurs in subsequent executions of the same goal, the generated restart address value will not be smaller than the previous restart address value, so the restart pointer 13 will be set to the restart address that was initially set. The value is saved.

In this way, when a goal that is in a suspended state is connected to the executable goal queue and resumes execution as before when the value of the hooked variable is determined,
The execution processing unit 10 executes the goal control block 20 of the goal.
The first close to be executed is determined based on the address value held by the restart pointer 13 located at , and execution of only subsequent closes is started.

FIG. 3 shows an example of the flow of the suspension process of the execution processing unit 10. When a suspension condition is detected, in processing step 30, the hook pointer 1 of the cause variable is set to the suspension record 2.
from the suspension record 2 to the goal control block 20 via the suspension flag record 3.
The pointer is set to point to , and the number of variables in suspension flag record 3 is incremented by 1.

In processing step 31, a restart address value is generated to point to the close that is currently being processed, and in processing step 32, it is compared with the value of restart pointer 13, and only if the restart address value is smaller than the value of restart pointer 13, Processing step 3
3, the restart address value is set and the restart pointer 13 is updated, and if not, the value of +'+il of the restart pointer 13 is saved as is.

[Effects of the Invention] As is clear from the above description, according to the present invention, when restarting the interrupted execution in the execution interruption process of a logical language program, the execution after restarting can proceed efficiently. This has a significant effect.

[Brief explanation of the drawing]

FIG. 1 is a block diagram showing the configuration of the present invention, FIG. 2 is a diagram showing a goal suspension state of the present invention, FIG. 3 is a flowchart of the processing of the present invention, and FIG. 4 is a diagram showing a conventional goal suspension state. FIG. In the figure, 1 is a hook pointer, 2 is a suspension record, 3 is a suspension flag record, 4.20 is a goal control block, 10 is an execution processing unit, 11 is a program, 12 is a goal, 13 is a restart pointer, and 14 is an initial value , 30 to 33 are the processing steps ＼ □□□

Claims (1)

[Claims] A given program (11) consisting of clauses of a predetermined logical language is executed sequentially for a required goal (12) starting from the closing with the lowest number, and a predetermined interruption condition is detected. , when the execution of the goal is interrupted, a restart pointer (13) is provided for each goal (12), and if the restart address value is smaller than the value held in the pointer, the restart address value is used. The restart pointer is updated, the restart address value is determined to instruct the closing of the execution target at the time of the interruption, and the restart pointer (13) is set to a predetermined initial value (14).
The initial value (14) is a value that is not smaller than the address value that instructs the final closing, and when the predetermined restart condition is satisfied for the goal (12), the restart pointer is set to Resume execution from the specified close (10)
A logical language program execution processing method characterized by being configured as follows.