The method invocation mechanism and the System Stack

Introduction
- We have now learned all material necessary to understand how the method invocation mechanism works.
- Here is a method invocation:
- In this webpage, I will show you what happens behind the scene in a method invocation
- Know what is going on will help you understand the concept of the parameter passing mechanism (and why there is no side effect)

Previously discussed

Execution units:

Statement = the smallest execution unit in a Java program
Method = contains multiple statements that is identified by a (method) name

What happens when you invoke a method

Purpose of calling (invoking) a method:

Phases of a method invocation:

Give (pass) the necessary information to the method so that it can do its job.
Example:
During this phase, the parameter variables are created and initialized with the proper value (using the passed value)

The method performs the task

In order to perform the task, the method may need some scratch space to perform the necessary computations.
In other words:
As you have learned previously, these local variables are privately owned and used exclusively by the method.
No other method can access them.
Furthermore, these local variable will be destroyed when the method exits.

The method may return back a return value to be used at the point of invocation

The mechanism to "return a value" has been discussed previously - See: click here

Summary:

The return value is saved in a register inside the CPU:
When the execution returns back to the point of invocation, the computer will use the value in the return location:

The method returns back to point of invocation

Notice that a method can be invoked (called) from different program locations:
Important fact on method invocation:
Example:

Now you know the theory of method invocation
I will now show you exactly what happens with an example of method invocation

Preparation for an example of method invocation

I will use the following program:

Note:

The program on the left are written in Java
The Java program must be compiled (translated) into machine (computer) instruction first and store in RAM memory for execution
The program (in RAM memory) on the left are the compiled machine (computer) instruction
The point A and point B are 2 memory addresses where the method ToolBox.min are invoked
Notice that the locations have different addresses because they are different locations in RAM memory.

Attention:

Pay attention to the order in which the parameter variables and local variables are created and destroyed
You should discover the LIFO ordering and realize that we are using a stack

OK, let's rock and roll...

The method invocation mechanism - explained using an example

We begin with the start of the program:

The execution begins in the main method:
When execution reaches double r, some space is reserve on the System Stack for the variable:
When execution reaches r = ToolBox.min(1.0, 4.0);, it triggers the method invocation mechanism that we will discuss next:

Phase 1: give (pass) the necessary information to the method ToolBox.min

The value 1.0 and 4.0 are passed as follows:
Schematically:

There is one more thing that the method invocation mechanism must do:

We must make sure that the method ToolBox.min can return back to the proper invocation point !!!
To enable the method ToolBox.min to return back to the proper invocation point, we must also pass (copy) the invocation location A on the System Stack !!!

Schematically:

Phase 1 is now complete and the execution continues with the method ToolBox.min:

Phase 2: the method ToolBox.min performs its task

When execution reaches double m = 0;, some space is reserve on the System Stack for the variable:
When execution reaches the if-else statement, it uses the variables on the System Stack to compute the result:

Phase 3: the method ToolBox.min returns back a return value

When execution reaches return(m), the value in variable m is copied into a return location (which is usually a register inside the CPU):

When execution reaches the end of the method, the local variable(s) m is destroyed:

Note:

Pay attention to the fact that the variables are destroyed in the opposite order of their creation !!!
This make is possible to use a stack to reserve space for parameter and local variables.

Phase 4: the method ToolBox.min returns back to the point of invocation A

The program will now use the value saved return location to return to the point of invocation (A):
The execution will then destroy the return location and parameter variables that it had created at the beginning of the method invocation:
The method invocation mechanism is now completed !!

Continued:
Conclusion:

Terminology: stack frame, procedure activation record
- The method invocation mechanism always constructs the following structure on the System Stack:
  This structure is called a "stack frame" or (older term) a "procedure activation record".
  
  Example: (see above in Phase 2)

Deeper nested method invocations

The method ToolBox.min is simple enough that we do not need to use other methods to complete the job.
But in general, if method ToolBox.min were to perform a complex task, it is advisable to:
Example: suppose method ToolBox.min uses another methods called someMethod:

When program execution reaches the point C where the min method calls the someMethod:

The system will again use the method invocation mechanism

The method invocation mechanism will another stack frame on the System Stack:

Create parameter variables on the System Stack
Create a variable containing the return address C on the System Stack
Create local variables on the System Stack

When method someMethod is executes, the System Stack will look like this:

Note:

Notice the new stack frame for the method someMethod is on top of that for the method min
Notice also that the parameters, return address and local variables of the method min remains in the System Stack area
These variables are not being used while the program is executing inside the someMethod method
(In fact, the execution of the someMethod method has been suspended as long as the program is executing inside the someMethod method)

When method someMethod is completed and the program execution is transfered back to the method min, the local variables, return address and parameters for the method method someMethod are destroyed.
The System Stack will look like this:
We can clearly see that the procedure activation records are created and destroyed in the Last In, First Out manner.
(That's why the area that store procedure activation records is called the System stack).