JPS6367691B2 - - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION The present invention relates to a functional information processing device for a functional language such as Lisp (List Processor) that processes symbols rather than numbers, and particularly relates to a functional information processing device for a functional language such as Lisp (List Processor), which processes symbols rather than numbers. When storing (what to use as the value of a variable) in the memory circuit inside the computer in a stack structure, the associative information is stored outside the stack memory in order to shorten the search time for variables stored in the stack. The present invention relates to a functional information processing device characterized by providing a buffer and a counter.

Lisp handles a binary tree list as shown in Figure 1, that is, a tree structure (Figure 1a) in which the connections of symbols are expressed as a set of nodes and branches that do not include cycles. In other words, the connection of symbols expressed in the tree structure shown in Figure 1a is shown in Figure 1B.
There are two branches coming out of each node as in 2
It is stored in the main memory as shown in FIG. 1c in the form of a forward tree representation. That is, each list cell consists of one or two words of main memory, and each cell consists of two parts, a left and right part. The left part of each cell usually stores the bit pattern of a symbol, such as the letter A, and the right part stores the address of the cell that stores the next symbol that should be connected to that symbol. represents that two cells are connected. Therefore, the connection of list cells in FIG. 1c is the realization of the binary tree list in FIG. 1b on the memory circuit. Lisp is a device that dynamically converts such a list structure using a processor by executing the Lisp language to obtain the desired list structure.

Programming in Lisp means
The purpose is to define a function formed by combining the following five basic functions necessary for converting a binary tree list, and to find its value.

The five basic functions are: (a) car [X] Curl The value is the binary tree list at the end of the left branch of the binary tree list X.

(b) cdr [X] cdr The value is the binary tree list at the end of the right branch of the binary tree list X.

(c) cons [X:Y] cons Create a new list cell and change its left branch to 2
Create a new binary tree list such that the binary tree list is X and the right branch is the binary tree list Y, and use it as the value.

(d) atom [X] Atom When X is an atom, the value of true (“T” or “*
T*”), and if not, it is false (denoted by an atom “NIL”).

(E) eq [X:Y] Ik When X and Y are the same binary tree list, take a true value (“T” or “*T*”), and when not, take a true value (“T” or “*T*”)
Takes a false value (“NIL”).

For example, f(x,y)=x ^y +y ^x is defined as f=λ
By expressing [[X, Y]; X ^Y + Y ^X ], f
The value of (2, 3) is λ[[X, Y];X ^Y +Y ^X ][2,
3] = 2 ³ + 3 ² , and the correspondence of variables can be clearly defined.

Here, (X, Y) are variables called formal arguments, and (2, 3) are the current values of (X, Y) called actual arguments. Assigning the actual arguments (2, 3) to the formal parameters (X, Y) is called binding, and by binding the actual arguments to the formal parameters, the value of the function, in this case
Creating the desired list 2 ³ + 3 ² is executing a lisp. Therefore, in the case of a lisp, that is, a functional information processing device, the problem is how to bind formal arguments and actual arguments.

In the present invention, the binding value of a variable (Bind
Value) is a linear list (environment list) i.e.
FILO (First In Last Out or Push down Pop
up) type stack as a variable name and value pair.
Here, FILO type stack means 2
Data is stored using an indirect address method (that is, a method in which one cell stores the address of the next cell) in a tree list structure. The order in which pairs of variable names and values are stored is the order in which the actual arguments are used as values when the function of the argument variable is called. In a type language, the procedure for referring to the value of a variable is basically to sequentially search the environment list (or stack) above from the beginning and use the first value found. When performing deep bind type variable binding, global variables (unlike local variables, such as function arguments, whose binding value is determined when the function is started, whose value has been determined before that time) In addition to the main memory, there is an associative buffer and +1 at function call and return to shorten the access time to search for (predetermined variables).
A feature of the present invention is to provide a counter that is set to -1.

Generally, as shown in Figure 2, a functional type is a function that the program structure or execution form should call, that is, a function that should be executed f = λ [[X, Y]; X ^Y + Y ^X ]
Binds the actual arguments (2, 3) to the formal arguments (X, Y), and the called (invoked) function refers to the passed or assigned actual arguments and global variables. The function executes the specified procedure, returns the value 2 ³ + 3 ² of the function to the caller, and has no other side effects (changes to the environment).
In view of the gist of the present invention, description of side effects will be omitted.

When calling a function, there are two methods for binding actual arguments to formal arguments: deep binding and shallow binding.

As mentioned above, the deep binding method creates a stack structure in which pairs of bound variable names (X, Y) and values (2, 3) (i.e. pairs of X for 2 and Y for 3) are stored as a linear list. When referring to a variable value, the environment is structured so that the value of the variable is sequentially traced from the last bound direction and the value of the variable found first is used.

In other words, in the deep binding method, as shown in Figure 3a, the structure of a word, which is a storage unit in the main memory, is divided into two parts, left and right, forming one cell, and the variable name is written in the left part. By storing the address of the next cell to which that cell is connected on the right side, you can know the value of that variable in the next cell. They are connected as shown in FIG. 3 to equivalently constitute a FILO type stack as shown in FIG. 3b.

When binding a value to an argument variable during a function call, connect the name and value pairs from the direction of the search starting point in the environment list (or environment stack) and add a new search starting point pointer. Update to the beginning of the item. That is, Figure 3a
On the main memory device of , this corresponds to providing one cell n+1 at the beginning, and corresponds to the fact that the next cell to which that cell is connected is n. This is shown in Figure 3b
corresponds to the stack push operation A, which corresponds to pushing a cell whose variable name is n+1 and whose value is (n+1) to the bottom of the stack. When a function returns, the search starting point pointer is returned to the state it was in when the function was called. That is, on the main memory circuit in FIG. 3a, the first cell n+1 is set as one cell, and cell n is set as the first cell, and in FIG. 3b, n+1 and its value (n+
1) means to take it out with pop action B.
The advantage of the deep binding method is that the push and pop operation of the stack is simple, so there is relatively little overhead for binding argument variables when a function is called and unbinding processing for argument variables when the function returns. The disadvantage is that it takes time to reference variables that were bound long ago, or are located deep in the stack, such as global variables (also called free variables).

In the shallow binding method, a random access area (called a value cell) is created for each variable to hold its value, and when a function is called, the actual argument is stored in the value cell of the argument variable, and the value that previously existed in the value cell is stored. , stored in a linear list (or stack) as a pair of name and old value, and variable references only need to read the corresponding value cell, and when the function returns, store the argument variable's value cell in the linear list (or stack). Return the old value. The advantage of the shallow binding method is that the argument reference time is short, and the disadvantage is that the overhead of binding argument variables when a function is called and unbinding when the function returns is large.

As described above, the deep binding method is faster in the binding/unbinding processing of arguments than the shallow binding method, but it is slower in referencing variables, especially global variables. That is, in the past, variables were referenced in a sequential manner in which the pointer was decremented one by one, resulting in very slow processing. The method of the present invention improves this point.

SUMMARY OF THE INVENTION An object of the present invention is to provide a functional information processing device as described above, in which a list representing connections between data is stored in a main memory in order to shorten the access time of referring to variables stored in a stack memory according to a deep binding method. It is an object of the present invention to provide a functional information processing device provided with an associative buffer and a counter that increments +1 and -1 when a function is called and returned, respectively, outside the device.

The feature of the present invention is that the program structure and execution form is an environment list as a pair of variable names as formal arguments and variable values as actual arguments.
By storing in the First-In-Last-Out type stack memory, the actual argument is bound to the formal parameter variable of the function to be called, and when the called function refers to the value of the variable, the most recent In a functional information processing device that performs a process using the bound value of , and when the value of the function is obtained, the process of deleting the formal parameter variable of the function from the environment list and returning the function value is repeated. , +1 and -1 each time the function is called and the function returns, respectively.
It has an associative buffer memory in which each word is made up of a counter, a variable name, position information of the variable's environment list, and the counter value when the variable is referenced and registered. First, the associative buffer memory is accessed as a key, and if it exists, the variable value is found from the position of the corresponding variable on the environment list. If it does not exist, the environment list is traced back while decrementing the counter FCTR for each function frame. Search and use the value of the first variable found, its variable name, FCTR value,
By providing a functional information processing device that stores addresses on an environment list (or stack) in a buffer as a pair, and deletes words in the associative buffer that match the counter value of the function when the function returns. be.

An embodiment of the present invention will be described below with reference to the drawings.

First, in the deep binding method on the stack, the following processing is performed. When the actual arguments are ready before the function call occurs, the stack is as shown in Figure 4a.
become that way. Here, STP is a stack top pointer. When a function is called, the called function looks like the one shown in Figure 4b.

Through the above processing, information for each function in the stack is linked by the old FP as shown in Figure 4c. Here, FP is a frame pointer, that is, it points to the beginning of the control information of the function currently being executed. When a variable is referenced through this link, its value can be obtained by following it and searching for the variable name.

For example, for three functions in the relationship F ₁ (z)=z ² +F ₂ (10) F ₂ (x)=x ² +x+F ₃ (7) F ₃ (x)=x ⁵ +1+z, F ₁ (3) The case of finding the value of will be explained. When the function F ₁ (z) is called, the formal argument z is bound to 3, and the binding relationship is stored on the environment list. but,
Since the value F ₂ (10) of the function F ₂ (x) is required to count F ₁ (z), the function F ₂ (x) is called. At the time of this call, the formal argument x is bound to 10, and the binding relationship is stored on the environment list. but,
Also, since the value F ₃ (7) of the function F ₃ (x) is required to calculate F ₂ (10), the function F ₃ (x) is called. At the time of this call, the formal argument x is bound to 7, and the binding relationship is stored on the environment list. However, to find the value F ₃ (7) of F ₃ (x), F ₃ (x) = x ⁵ +
z in 1+z is a global variable, that is, a variable that is not bound at that point, but z is bound to z=3 at the time of calling F ₁ (z), so if you go back on the environment list and find that z is 3. This is what we search for. And for the first time F ₃ (7)=7 ⁵ +1+
3 is found, return to F ₂ (x) and get F ₂ (10)=10 ² +
10+F ₃ (7) is found, return to F ₁ (z), and F ₁
(3)=3 ² +F ₂ (10), and the value F ₁ (3) can be found.

Generally, in a functional information processing device, the number of global variables is smaller than that of bound local variables (or formal arguments), but a small number of global variables are often referenced many times. Therefore, in the functional information processing device of the present invention, an associative buffer and a counter that is incremented by 1 and -1 when a function is called and returned, respectively, and when a variable is searched on the environment list (or stack) are provided. When a global variable is referenced, if the variable does not exist in the buffer,
The environment list (or stack) is searched sequentially, and the position information of the stack where the variable name is stored, for example, the address is paired with the variable name, and the contents of the counter corresponding to the environment block where the variable is found are also retrieved. Each word is stored as one word in the high-speed associative buffer memory, and when that variable is referenced from now on, the buffer can be accessed associatively using the variable name, greatly shortening the access time. At the same time, when the function returns, the corresponding word in the associative buffer can be deleted at high speed using the contents of the counter as a key.

In the environment list in Figure 5, the function F ₁ calls F ₂ ,
F ₂ is F ₃ , F ₃ is F ₄ , F ₄ is F ₅ , and F ₅ is F _6.
Suppose you are learning to call . At this time, it is assumed that the function F ₆ is F ₆ (N)=N ² +x+z+z ² . That is, N is a local variable,
x and z are global variables. The global variable x is bound so that x = 5 when calling the function F ₂ (x, y), and z is bound so that z = 8 when calling the function F ₃ (z). is bound by. In order to calculate the value of F ₆ (N), the environment list is first searched in order to refer to the variables N, x, and z. However, for the local variable N, the value (for example, N= 10), but for x and z, it is necessary to search backwards on the environment list, and it turns out that x=5 and z=8. However, if, in this first search, we store x=5 and z=8 found as a pair in the association buffer as shown in Figure 5b, the second reference to the same variable name will cause the association buffer to be stored. This can be done faster by accessing the information first. In other words ^, the last term z 2 of F ₆ (N) = N ² + x + z + z ² has the pair z = 8 stored in the associative buffer, and if an associative search is performed using the variable z as a key, z
It is immediately determined that =8, and it is sufficient to substitute it for z ² . Furthermore, counters that are incremented by +1 and -1 at the time of a call and a return, respectively, as will be described later, are provided to quickly delete words that are no longer needed in the buffer.

Next, the functions that buffer memory should have are as follows. The specific structure of the buffer memory will be described later with reference to FIG.

(1) When accessing a global variable for the first time, register the variable in the buffer to speed up subsequent accesses. In this case, position information (address in the stack) of the variable name and its bind value on the environment list (or stack) is also stored, and the variable value is extracted from the stack in a random access manner by referring to the address in the stack.

At the same time, an externally provided counter FCTR (Function Counter), whose buffer entry (word) format is shown in FIG. ) When searching backwards, perform a countdown for each environment block, and when registering a variable to the buffer, write the FCTR value corresponding to that environment block to the buffer's FNO area, and when the function returns, the FCTR value
Pairs of FNO areas are provided for use in deleting buffer entries with FNO areas that match the value. Note that the variable name, that is, the name area, is used as a key when referencing a variable, and is used to delete the variable when binding the variable during a function call. Additionally, the FNO area is used to distinguish which function's argument the corresponding variable is. Furthermore, the pointer area points to an address on the environment list or stack where other variables are stored, and when accessing a variable, the environment list (or stack) is accessed using the pointer area of the entry with the matching variable name. . In FIG. 6, V indicates a valid display bit.

(2) Check whether the given variable name matches the internally stored variable name or not, and if there is a match, read the stack address corresponding to that variable name. In other words, use the variable name as a key to create a buffer. It has the ability to perform associative searches and read attack addresses. This is necessary when referencing variable names.

(3) It has a function of using a variable name as a key to reset the valid display bit V of a variable with the same name as that variable on the buffer memory. This is necessary because when calling a function that has the same formal argument name as a referenced global variable that exists in the buffer, that global variable on the buffer is deleted. If this information occurs, the scoping principle that gives priority to local variables over global variables when referencing the same variable name breaks down.

(4) It has a function of using position information (FCTR) on the list as a key to reset the valid display bits V of all items that match the position information (FCTR). This is necessary to remove all argument variables of the returning function from the buffer when the function returns to the calling function. If this process occurs, if a variable with the same name as a formal argument variable of this function was bound before this function, and that variable is referenced, a value that should have already been removed from the environment may be mistakenly used. become.

As mentioned above, if each variable is not stored in a buffer with an FCTR value corresponding to the function frame position in the environment, each buffer will be searched and removed using each formal argument name of the returning function as a key. Or you need to clear all of the battles. In the former case, it takes time, and in the latter case, the lifetime of the global variable in the buffer is until the function that references it for the first time returns, and the effect of the buffer is almost negated.

The operation of the buffer will be explained below. First, refer to variables as follows. Search the buffer using the variable name as a key, and if it exists, access the value on the stack using the pointer area. If it does not exist, search the environment list (stack) using the variable name as a key. At this time, FCTR is counted down by going back one function frame, and the first variable value found is used. and,
Register the variable name, FNO area (FCTR corresponding to the found function frame), and pointer area to the buffer,
It is provided for future reference.

Function calls are made as follows. If the function to be called has an argument, delete the buffer entry whose name area matches the formal argument variable to avoid accidentally accessing a variable with the same name in the buffer.

Then, the function return is performed as follows. If the returning function has an argument, delete the buffer entry whose FNO area matches the current FCTR corresponding to the function frame. This prevents the old bind value of this argument variable from remaining in the buffer. Then count down the FCTR and set the FCTR corresponding to the function frame to return to.
value.

As mentioned above, the role of FCTR is to use the FCTR value as a key when unbinding the argument variables upon function return, even if there are multiple arguments.
The purpose is to clear all buffer entries whose FNO area matches it at once.

FIG. 7 shows the associative buffer memory of the present invention and +1 at function call and return, respectively.
It is a concrete block diagram of the counter which carries out -1. In other words, by storing the structure and execution form of the program in the environment list as pairs of variable names and variable values, the actual arguments are bound to the formal argument variables of the function to be called, and the called function stores the values of the variables. When referring to , the most recent binding value in the environment list is used to perform the process, and if the function value is obtained, the function's formal argument variable is deleted from the environment list, and the function value is returned. There is an associative buffer memory inside the functional information processing device that repeats the process, and +1 and -1 at function call and return, respectively.
FIG. 2 is a configuration diagram in which a new counter is added.
The functions that the associative buffer memory should have are as follows.
(1), (2), and (3).

In the above embodiment, first, memories 10 and 30 are provided, each of which is composed of 1 to m registers. The memory 10 is a variable name area memory that stores variable names, and when the variable name is stored in the memory 10, the memory 20 has a counter 21 that counts up each function frame.
This is FNO area memory that stores the current value of
Memory 30 is a pointer area memory that stores addresses within the stack. i of the memories 10 and 30
The th (i=1, 2, . . . n) registers correspond to each other and form one word. When a certain variable in the environment list of a functional information processing device is accessed for the first time, the contents of the FCTR counter 210 and the stack address of that variable are registered in the memories 10 and 30 of the associative buffer, respectively, and subsequent accesses are performed. Aim to speed up the process. To register in the associative buffer, use input line 10 for variable names.
1, 103 to activate a write pulse signal WE _i (not shown) and write to the cell with variable name i.
At the same time, the contents of the FCTR counter 210 are written to the i-th cell in the RNO area through the input lines 201 and 203 by activating the same write signal _WE i.Similarly, the address in the stack is written from the input line 301 to the pointer area. The write signal WE _i is activated and written to the i-numbered cell. The associative buffer detects in advance whether a given variable name matches in the internal memory 10 and the matching circuit 40, and if a match is found, one of the n output lines 401 is activated and selected. The circuit 60 is controlled to output the contents of the corresponding cell 30, ie, the address in the stack, to the output line 601. That is, an address in the stack can be read by performing an associative search using the variable name as a key. Moreover,
The memory 30 that stores addresses in the stack is also writable, and addresses corresponding to variable names can be read and written. This is necessary when referencing or changing addresses.

In addition, in order to realize the function of resetting the valid display bits V of the FNO area of the same pattern from the associative buffer using the contents of the counter FCTR 210 as a key, this embodiment includes a group of valid display bit storage cells 80 and a valid display bit V. An update circuit 90 is included. Cell group 8 storing valid display bits V
0, the _Vi cell is set by the variable update circuit 90 by the write signal WE _i (not shown) when writing variable name i and address i.

If the output 501 of the matching circuit 50 is selected, when the input counter content output 201 matches the FNO area pattern stored in the memory 20,
The corresponding valid display bit is reset and the FCTR
Using a value as a key, buffer entries whose FNO area matches that value can be cleared all at once.

The variable name is n-way Replace Logic 10.
0, and its output is stored in memories 10, 20,
It should also be added that it is connected to 30 inputs.

As described above, according to the present invention, in a functional information processing apparatus that executes execution according to the deep binding method, access for searching the value of a variable is increased by +1 at each of the associative buffer, function call, and return. , -1 can be used to speed up the process.

[Brief explanation of drawings]

In Figure 1, a, b, and c are diagrams explaining a binary tree list, Figure 2 is a diagram explaining functional information processing, and Figure 3 is a diagram explaining a binary tree list.
Figures a and b are diagrams explaining the deep binding method, Figures 4 a, b, and c are diagrams explaining the deep binding method on the stack, and Figure 5 is a diagram specifically explaining the deep binding method on the stack. FIG. 6 is a diagram showing the format of a buffer entry, and FIG. 7 is a block diagram of an embodiment of the buffer used in the present invention. 10... Variable name area memory, 20... FNO area memory, 21... Counter, 30... Pointer area memory, 210... FCTR counter, 40, 50...
. . . matching circuit, 60 . . . selection circuit, 80 . . . valid display bit storage cell group, 90 . . . valid update circuit.

Claims (1)

[Claims] 1 The structure and execution form of the program determines the function to be called by storing pairs of variable names as formal arguments and variable values as actual arguments in a First-In-Last-Out type stack memory, which is an environment list. When an actual argument is bound to a formal argument variable and the called function refers to the value of the variable, the most recent bound value in the environment list is used for processing, and if the value of the function is obtained, the function's formal argument is In a functional information processing device that repeats a series of processes of deleting a variable from the environment list and returning the function value, each time a function is called and the function returns, +
1. It has an associative buffer memory in which each word is made up of a counter that is decremented by 1, a variable name, position information in the environment list of the variable, and the counter value when the variable is referenced and registered. , first access the associative buffer memory using the variable name as a key, and if it exists, find the variable value from the position of the corresponding variable on the environment list; if it does not exist, search for the variable name from the environment list and first 2. A functional information processing apparatus, characterized in that when a function returns, a word of the associative buffer that matches the counter value of the function is deleted.