- Computer Program:
- A computer program consists of:
- Program instructions
(statements in
the computer program)
- Program variables
- Program instructions
(statements in
the computer program)
When a program is run (executed), the instructions and variables must be stored in the computer memory (so the CPU can access (= used) them !!!)
- A computer program consists of:
- Prelude to
program organization:
- We do not store
the content of a
computer program
haphardly into the
computer memory
- Over the many years of
computer usage,
we have settle on
a specific organization
- But before I can explain the program organization to you, we need to discuss about the life time of variables....
- We do not store
the content of a
computer program
haphardly into the
computer memory
- In CS170/CS171, you have learned
about the life time of
program variables
- As a refresher, I want to
remind you what "life time" means:
- Life time = the duration in which a thing exists in the computer memory
- As indicated in te beginning of
this webpage, there are
2 kinds of
things inside a
computer program:
- Program instructions
- Variables
As prequisite to the discussion of program organization, I will now review the "life time" of these things
- The statements inside a
computer program must
always be
available to the
computer for execution
Therefore:
- The life time of
a program instruction is
- From when the program starts running
- Until the program exits
- The life time of
a program instruction is
- Recall
that Java has
4 different
kinds (not
type) of
variables:
- Class variables
- Instance variables
- Local variables
- Parameter variables
- Recall on
how to
recognize the
different kinds of
variables:
public class ExampleClass { static int x; // Keyword static defines a Class variable int y; // Absent of static defines an Instance var public int Method1( int a ) // a is a parameter variable { int b; // Local variables are defined inside a method .... } }
- The life time of
Class variables:
- Begins: from the start of execution of the Java program
- Ends: at the termination of the Java program
- The life time of
Instance variables:
- Begins: when the instance variable is created by a new operation
- Ends: when the instance variable becomes garbage (i.e., inaccessible)
- The life time of
parameter variables:
- Begins: at the start of the method execution
- Ends: at the termination (= return) of the method execution
- The life time of
local variables:
- Begins: at the start of the method execution
- Ends: at the termination (= return) of the method execution
- In summary, we can categorize
the instructions and variables into
3 different categories according to
their
life time property:
- "Permanent" things
(the instructions and
the class variables):
- These have a life time that starts when the program begins and ends when the program exits
Notice that the size of the "permanent" things in a program is fixed during the entire execution of the program !!
- "Local" things that
belongs only
to a function
(i.e.: the parameter variables and
local variables):
- These have a life time that starts when the function/method begins and ends when the function/method returns
Notice that the size of the "local" things in a program is variable during the execution of the program.
New parameter and local variables are created when a function begins
These parameter and local variables will remain until the function returns
There is a First In Last Out relationship in function invocations (i.e.: the function that is called first will be the last function that returns. E.g.: if A( ) calls B( ), and then B( ) calls C( ). Then order of function return is: C( ), B( ) and A( ))
- "No-specific-timing" things
(the instance variables):
- These have an unpredictable life time....
The size of these things in a program is also variable during the execution of the program.
There is no specific ordering in which the instance variables are created and destroyed....
- "Permanent" things
(the instructions and
the class variables):
- Important fact:
- The 3 categories of "things" in a computer program are stored differently in the computer memory to maximize efficiency !!!
- Every computer system today
uses the following
program organization to
achieve
maximum memory efficiency:
- The following diagram shows
the storage organization of the
program instructions and
the various
kinds of variables
in the computer memory when
a program is
run:
Explanation:
- The top of the memory contains
the permanent things
in a computer program:
- The program instructions
are stored
at the beginning of the
main memory
- The Class variable (which exists for the entire program execution) are stored after the program instructions.
The program instructions and class variables will occupy the top of the memory for as long as the program is running !
- The program instructions
are stored
at the beginning of the
main memory
- The program "heap":
- The program "heap" is the
area of memory located
right after the
fixed variables area
- When a Java program invokes
the new operator to
create an
instance variable,
some memory cells in the
program "heap" area
will be reserved for
the new instance variable
- The growth direction is towards the end of the memory (downwards in the above diagram).
- When some instance variables are
garbage collected (= destroyed),
the reserved memory cells will
be reclaimed (= "recycled").
- The program heap is therefore a dynamically changing memory area used to store instance variables
- The program "heap" is the
area of memory located
right after the
fixed variables area
- The program stack:
- The program stack is the
area of memory located
at the end of the
memory
- When a Java program invokes
a function/method, the
parameters of the function/method
and its local variables will
be created.
Some memory cells in the program stack area will be reserved for the new parameters and local variables
- The growth direction is towards the top of the memory (upwards in the above diagram).
- When the function returns,
its parameters and local variables are
destroyed and
the reserved memory cells will
be reclaimed (= "recycled").
- The program stack is therefore a dynamically changing memory area used to store parameters and local variables in function invocations
- The program stack is the
area of memory located
at the end of the
memory
- The top of the memory contains
the permanent things
in a computer program:
- When a program
starts its
execution, the
memory usage will be
as follows:
The memory contains only:
- Program instructions
- Class variable
The system heap and system stack are both empty.
- When a Java program executes
a new operation,
e.g.:
x = new BankAccount( .... );the new operation will allocate (= reserve) memory in the program heap for all the instance variables in the (BankAccount) object:
Note:
- The Java run time system will
maintain information on
which memory locations are:
- Available for use (i.e., free)
- Occupied
so that a memory cell is not used for/by different variables !!!
- The Java run time system will
maintain information on
which memory locations are:
- Restarting the
discussion from the beginning.....
When a program
starts its
execution, the
memory usage will be
as follows:
- When we invoke a
method,
e.g.:
x = Math.sin( 3.14 );The method invocation will allocate (= reserve memory) the parameter variables and the local variables of the method on the program stack:
- "Creating" a
variable:
- Create a variable =
allocate (= reserve) the
memory space (= cells) for
a variable
(Memory cells that are allocated (= reserved) can not be used for another variable !!!)
In other words:
- There is
no real creation
taking place
in variable "creation"
(Nothing like the creation in Genesis 1:1 of the Bible)
- Create a variable =
allocate (= reserve) the
memory space (= cells) for
a variable
- "Destroying" a
variable:
- Destroy a variable =
de-allocate (= unreserve) the
memory space used by the
variable
(The memory cells used by the variable can now be re-used by another variable !!!)
- Destroy a variable =
de-allocate (= unreserve) the
memory space used by the
variable
- I will explain
- How to allocate/de-allocate memory in more details later in the course
- Later,
I will also explain:
- Why we use a stack to store parameter and local variables ( click here )....