JPS585851A - Function type information processing unit - Google Patents

Abstract

PURPOSE:To speed up the reference of variables in a frame on an environmental list by providing the titled unit with a register directly indicating the leading value of a local variable value group on a stack of a variable restricting block lately inputted to an external device of a main starage device. CONSTITUTION:When a local variable is referred at compiling, the local variable name and the variable number are stored. A register for a program pointer PP, a specific pointer indicating the leading value of a local variable value group, is conncted as one hardware. When a block is updated on the supposition of PP=EP-[contents of (EP-1)]*2, stacks of the block are accessed at random by the contents of a PP register in accordance with (the variable refference PP + the variable number) if the PP indicates the leading value of the local variable value group, so that the variable can be referred quickly. The EP is a pointer indicating the latest variable restricting block.

Description

[Detailed Description of the Invention] The present invention is a squirrel that processes symbols instead of numbers! (Llsp
When it comes to information processing devices such as Li5t Prestss@r), the function is executed 1! Set the border (what should be used as the value of the variable) to the memory circuit inside W Nbi Island-Yu.
To store it structurally #) nine times the variable stored in that start point O to shorten the search time stone nine point above star V! Mail O
The first step regarding an intermittent information processing device that is characterized by having external registers is to convert a binary tree, a list, i.e., a list, as shown in jllll, into a main structure that is a set of nodes and branches ( It deals with things that are created in the ``ill←)''. In other words, the symbol ``O Tsuna'', which is created in a power tree structure, is handled by the branch that appears at each node, as shown in the ``first division''. 1st m1 with a large fist, changing the expression to 2 strokes, which is 3 strokes each.
Store in the main memory as indicated by (@).

In other words, the 4th to 9th strokes are 1. The word ``mara'' is from 21I to ejlso04) The dragon bows from two parts, the left and the right. The left part of the jar usually stores i, which represents a certain symbol, and nine, for example, which represents the symbol for the letter 'm'.
The right O part stores the next symbol that the symbol should be, and by storing the II position of the cell, it expresses that two cells are connected and 'cv-hh'.

Therefore, the length of rimetoshichiru') in Figure 1 (o) is,
The binary launch list shown in FIG. 1(b) is stored and realized on the road. Lisp is a device that dynamically converts such a list structure using a processor by deepening the Lisp language to obtain a -target0 list structure.

squirrel! The thing about smell τ program is #l! to convert the binary book list! The purpose is to define a function formed by combining the following five basic functions and find its value.

What are the five basic functions?

b) l4ar(X] Curl binary tree squirrel) Take the binary list at * on the left branch of X as the value.

Mouth) Cry (X) #dar 1 path tree list to the right of X 12) aO* to take the value of the 2 path tree list.

J%) l-'om*(X:Y) :I yxCreate a new list cell, and create a new list cell with the left branch as 2-launch list X and the right branch as 2-tree, list Y. Create a binary launch list and use it as the value.

2) h jam Cx) When atom .

e)・q(X:Y) Iku X and Y are the same 2! l! When it is a tree list, it takes 1 true value (``T'' or 1 city TI#), otherwise it takes a false value ('NIL).
")I take the.

For example, the definition of % / (217)■3EF + y” is!
−λ((x +y) ;x'+y'')
”)(2,3)-2”+32), the correspondence of variables can be clearly defined.

Here, (X, Y) are variables called formal parameters, and C
2m5> is called an actual argument, which is the current value of (x e y ). And this 0 actual arguments (2, 3
) is assigned to formal arguments (X, Y) K by binding (bjnd
lng) and create a desired list of function values, in this case 21 + 32, by binding the actual arguments to the formal arguments. Hence the squirrel! In other words, in a functional layer information processing device, the problem is how to bind formal arguments and actual arguments.

In the present invention, the bound value (ilind Val
tI・) is a linear list (1mm soloist or FIL
O(Flrst In La5t Out j or Pu
5k down Popup) Stored as a variable name and value pair in the ffi database. Here, data is stored in a binary tree list structure on the memory circuit using a rank address method (i.e., a method in which the address of the next cell is stored in one cell). With Ikujin. The order in which pairs of variable names and values are stored is the so-called dyna ζ, which is the order in which the actual argument is the value when the function of the argument variable can be called, or the Kuskovinda (Dymami
＠8＠oping) The procedure for referring to the value of a variable with an environment of nu is basically to start the company's development list (or star) , search sequentially and use the first value found, I
So-called deep India (・D・・p limdm
When performing variable binding, in order to shorten the access time to search for local variables, a register j is provided outside the main memory that directly points to the beginning of the local variable value group on the stutter of the nine most recent variable bindings fo and ri. This is a feature of the present invention.

In general, as shown in Figure 2, the functional type means that! In the program structure, the function that the execution form should call, that is, the depth power function f-λ((X, Y) :x'+y'')
The called (invoked) function executes the predetermined procedure by referring to the passed or assigned actual arguments and global variables, and calls the function value 2"+3". Return to the side, other side effects (changing the ml boundary)
In view of the gist of the present invention, explanations regarding side effects will be omitted.

When calling a function, there are two methods for binding an actual argument to a formal argument: the deep/indian method and the shallow bind (8hall/vllind) method.

As mentioned above, the Digts quantity Indian method uses a pair of bound variable names (X, Y) and values (2, 3), that is,
X is 2. An environment in which Y is a pair of 3) is stored in an am list or stutter structure, and when referencing a variable value, it is sequentially retrieved from the direction in which it was bound last, and the value of the variable found first is used. The structure is

That is, in the deep bind method, as shown in FIG.
The right part is divided into two parts and becomes one cell, the left part stores the variable name, and the right part stores the address of the next cell to which that cell connects, thereby determining the value of that variable in the next cell. can be known and there are many variables, the third
They are connected as shown in Figure (a) to form a FILoffi star as shown in Figure (b).

When making a function call (Call), when pinpointing a value to an argument variable, use
The name and value pairs are connected from the direction of the search starting point, a new search starting point pointer is added, and it is updated to the top of the nine items. That is, on the main memory device of FIG. 3(a), this corresponds to providing one cell n+1 at the beginning and the next cell to which that cell is connected is n. this is,
In FIG. 3(b), the push of the stack, (Pu
sh) corresponds to the action, and its variable name is n+1,
Place the cell whose value is (n+1) at the bottom of the star!
, corresponds to si1 and input. Function return (R
@tten) When the function is called, it returns the search starting point to the state it was in at the time. That is, Fig. 3 (a
), the first cell n+1 is taken as the first cell, and cell Otori is set as the first cell.In the third cell), the cell +1 and its value (m+1) are set to 4. f-movement B means to take it out. The advantage of deep quantity Indian method is stack! , C, /, F Since the operation is simple, there are relatively few overloads in the binding process of argument variables when calling a function, and the un-bind process of argument variables when returning from a function. The disadvantage is that, like global variables (also called free variables), it takes time to reference variables that were previously bound, that is, variables that are deep in the stack.

The shallow binding method uses a random access area (Valu@C@11) that holds the value for each variable.
When a function is called, the actual argument is stored in the argument number cell, and the value that previously existed in the cell is stored in a linear list (9 is a star) as a pair of name and old value. The variable reference only needs to read the corresponding cell, and when the function returns, it is stored in the linear list (t or stack) of the argument variable and returns the old value. The advantage of the shallow/child Indian method is that variable 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 mentioned above, compared to the deep binding method and the shallow binding method, it is faster to ind/unbind the number of arguments, but referencing variables is slower. The process was very slow because it was done in a sequential manner, reducing the amount one by one. The method of the present invention improves this point.

An object of the present invention is to provide a functional fine information processing device as described above, in order to shorten the access time of referring to variables stored in the stack memory by using a deep binding method to store a list representing the connection of data relationships in the main memory. Setting a register that directly points to the beginning of the local variable value group on the star of the variable binding block that recently entered outside the device is a function function function that speeds up variable references within one frame (l function) on the environment list. The purpose of the present invention is to provide an information processing device.

The features of the present invention are! The structure and execution form of the program is First (Difficult-La-t) where the environment list is a pair of variable names as formal arguments and variable values as actual arguments.
- By storing in the stack memory of Oat ml, bind the variable to the formal argument variable of the function to be called, and when the called function refers to the value of the variable, use the most recent binding value in the environment list above. In a functional information processing device that repeats a series of processes in which a process is performed and the value of the function is obtained, the formal argument variable of the function is deleted from the environment list and the function value is returned, the recently entered variable binding A functional information processing device characterized in that it has a register that directly points to the head of a local variable value group on a program.
迄1 rokohiteyamasu.

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

First, the following processing is performed in the digbind method on the star. If the actual arguments are ready before the function is called, the process will look like Figure 4 (i). Here, 8TP is sume, kuto, and gui interface. When a function is called, it will be called and the form as shown in Figure 4(b) will be created on the nine function side. As shown in FIG. 4(b), the variable binding block is an area in which a binding pair of an actual argument and a formal argument is stored.

Through the above processing, information for each function in the stack is linked by the old FP as shown in FIG. 4(e). 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, F 1 (2) - Z" + F2 (10) F2 (2 on d-
+m+F3(7) F3(d-=5+1+z For the three functions in the relationship, Fl (3)
The case of finding the value of will be explained. When calling the function F1@), the formal argument 2 is bound to 3, and the binding relationship is stored on the environment list. The value F2(10) of the function P2(x) is required to calculate Fl(2))C)L
”, function F2) is called. At the time of this call, the formal argument Since the value F3 (7) of F3 is required, the function F3←) 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. To find the value F3(7) of (x), 2 of F3(x)=-+1+z is a global variable, that is, a variable that is not bound at that point, but 2 is Fl■)
Since it is bound to Z-3 at the time of pooling, we search back over the 1m boundary list to find that 2 is 3. And for the first time F3(7)-75+1+3
is found, return to F2(x) and get F2(10)-1
02+10+F3(7) is requested, y112) is 9! −
Then, Fl (3) ■ 32 + F2 (10)), Fl
The value (3) is found.

In the environment list in Figure 5, Seki@yi sets F2 to F2.
Assume that F3 calls F3, F3 calls F4, F4 calls F5, and F5 calls F6. In this case, function F6 is changed to F6(local a; amX+Z: return N2+a local a; is entry variable 1 used only within this function.
Assume that the declaration IJJ-N'+a: is the value returned by this function. That is, NFi is a local variable, and ear and 2 are global variables. The global variable X is a function F2 (!5y)t
It is bound to be x-5 at the time of the call,
2 is bound to be Z−S at the time of calling the function F3@).

To calculate the value of F6H, it is necessary to search on the environment list to refer to the variables a, N, °X, and 2.

According to the present invention, in order to perform local variable references within one frame (within one function) on the glist, a method is used to compact and deepen the globogram.When there is a reference to a variable, the definition of that variable is If it is the same function,
Search is no longer necessary. When using compactor, when looking at a local variable, the local variable name and the local variable number (variable number) are memorized, and when looking at a variable reference, the recent variable binding program is stored as the object code. ,
Empyromentor Ink Envlrom@n
You can create a code that obtains the value of a variable by indexing and cushing from tPo1nt*r(EP). Tsumashi, oh!
As the object code, (gp-x) is the address of the word storing the number of variables, and the contents of (IP-1) are the number of variables, so execute the following: Contents of IP-1-IJP-1]$2+variable number. In other words, the start address of the actual argument group (local variable group) +
If you issue the code for the variable number, there is no need to perform a sequential search, but local variables are referenced frequently, so
In order to execute the code, it takes time to perform rounding via an arithmetic circuit, and this alone is unsatisfactory.

Therefore, the present invention points to the beginning of one local variable value group as shown in FIG. Special pointers ie! log main l
A register for PP is provided in hardware. e here PP-
EP-1- (Contents of IcP-1) 2. When entering a new block, if you let PP point to the first local variable value group, when a variable is referenced, it will , variables can be referenced at high speed by randomly accessing the star register based on the contents of the PP register.

In this way, the present invention recently introduced nine variable constraints! The present invention provides a functional quantity information processing device that includes a register that directly points to a group of local variables on the register of a lock.

By providing this register, it is possible to refer to local variables within one frame at a greater distance.

[Brief explanation of drawings]

Figure 1 (a) e (b), (e) is a diagram explaining a binary tree list, Figure 2 is a diagram explaining functional information processing,
Figure 3 (1). (b) is a diagram explaining the deep binding method, Figure 4 (a)
). (b) and (c) are diagrams illustrating the bind method on the starboard, FIG. 5 is a diagram specifically explaining the deep bind method, and FIG. 6 is a diagram illustrating an embodiment of the present invention. FIG. STP...sta, cut, dein! , FP...Frame pointer, AP...Ai, Ment pointer Fact 5
Figure 6

Claims (1)

[Claims] 1. First -In -La5t -Oat ml where the structure and execution form of the program program is the environment as a pair of variable names as formal arguments and variable values as actual arguments.
Bind the actual argument to the formal argument variable of the function to be called by storing it in the stack memory of , function type information J6!, which repeats a series of processes in which, when the value of the function is obtained, the formal argument variables of the function are deleted from the above-mentioned boundary list and the above-mentioned function value is returned. 1. A function section information processing device, characterized in that the device has a register that directly points to the head of a group of local variable values on the star of a recently entered variable-bound block.