- Structure of
computer memory:
- Computer memory
consists of sequence
bytes
- Each bytes
consists of 8 bits
- A bit =
the most elementary
electrical memory element
- A byte can
"remember" (store)
either the
value 0
or the
value 1
(a byte is an electrical switch: it can be off or on)
Therefore:
- A byte
(= 8 bits)
can contain 28 = 256
different values
(A byte can remember only one specify value at a time.
A byte cannot remeber all 256 values at the same time)
- A byte can
"remember" (store)
either the
value 0
or the
value 1
- Each byte
is identified by an
address
- Computer memory
consists of sequence
bytes
- Usage of
a byte:
- Byte =
a memory element used to
store values
from a
small
representation set
Example:
- Character set:
a, b, c, b, e, ..... A, B, C, D, .... 0, 1, 2, ...., !, @, #, $, %, .... (Total approximately 128 different characters)
- Character set:
- Byte =
a memory element used to
store values
from a
small
representation set
- Larger memory cells are needed for larger value sets,
like integers, floating point numbers.
- 2 bytes are used to hold values of "short" integers (the short type in Java)
- 4 bytes are used to hold values of "ordinary integer" integers (the int type in Java)
- 8 bytes are used to hold values of "long integer" integers (the long type in Java)
- To make "larger" memory elements, consecutive bytes in
main memory are used together:
- Due to architectural (cost) constraints, some computer
will impose special limitation on where the variables
must be put/placed in memory.
Typical restrictions:
- short (2 bytes) integers must be placed at an even address (divisible by 2)
- ordinary (4 bytes) integers must be placed at an address that is divisible by 4
- An important Fact and a subtle question:
- Knowing that the computer memory consists of bytes and
each byte consists of 8 bits and each bit remembers
one of the value 0 or 1, we can conclude that:
- The computer memory contains ONLY a bunch of 0 and 1...
- How can the computer know where a specific variable begins and ends in memory ???
There are no markers in the memory to denotate where the address item are located and how big they are (how many bytes are used to hold the value of the item - short: 2 bytes, int 4 bytes, etc) !!!
- The computer memory contains ONLY a bunch of 0 and 1...
- Knowing that the computer memory consists of bytes and
each byte consists of 8 bits and each bit remembers
one of the value 0 or 1, we can conclude that:
- The answer to this subtle questions is found in the
compiler and programming language:
- When a variable of a given type is first defined in a program,
the variable stored in the computer memory.
The compiler will find an unused portion of consecute memory bytes to store the variable.
In addition, the starting location (= address) of the allocated memory and the size (number of bytes) are remembered by the compiler.
Schematically:
- When the compiler processes a variable definition
clause in a program, it assigns an unused portion
of the memory of the proper size (depending on the type of
the variable.
- After assigning the memory, the compiler record
- The variable name
- The starting location of the variable in memory
- The size of the variable
in its symbol table variable
(Remember, the compiler is a program and a program can have variables... The symbol table is one of the many variables used to write a compiler...)
- When the compiler processes a variable definition
clause in a program, it assigns an unused portion
of the memory of the proper size (depending on the type of
the variable.
- When the variable is referenced (used) later in a program
statement, the compiler will generate
native computer instructions to access the memory
used to store the indicated variable:
- When variable i is referenced in the program, the
compiler consults its symbol table
and determines that variable i is stored
in the 4 bytes starting at address 2880
- It will generate the appropriate computer instructions
to manipulate these 4 memory locations
- Note: You will soon see that you need to specify the SIZE of the memory data in EVERY assembler instructions !!!
- When variable i is referenced in the program, the
compiler consults its symbol table
and determines that variable i is stored
in the 4 bytes starting at address 2880
- When a variable of a given type is first defined in a program,
the variable stored in the computer memory.
- (Now you may understand why most programming languages require that you first define a variable before you use it....)
- Fact:
- Variables defined in a computer program will always be stored in a specific location (address) in main memory
- 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 .... } }
- Recall from
CS170
--- Life time of variables:
- Life time of a
variable =
the (time) period between:
- The moment that the variable begins to exists
- The moment that the variable ceases to exists
- Life time of a
variable =
the (time) period between:
- The life time of
Class variables:
- Begins: from the 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 (= exit) of the method execution
- The life time of
local variables:
- Begins: at the start of the method execution
- Ends: at the termination (= exit) of the method execution
- Important fact:
- Because the
life time
of the different kinds
of variables is different:
- Different kinds of
variables are
stored in the
computer memory
in different ways
(To maximize efficiency !!!)
- Different kinds of
variables are
stored in the
computer memory
in different ways
- Because the
life time
of the different kinds
of variables is different:
The following figures shows how variables types of variables and the program instructions are stored in memory when a program is executed:
- The instructions are stored at the beginning and these memory
locations will be marked as READONLY (no writing allowed)
- Then the static variables are stored after the program
instructions.
The program instructions and static variables will continue to occupy the memory for as long as the program is executing !
- The memory following the static variables are initially all
unoccupied ("free")
This portion of memory is used to "allocate space" for new variables
When a new variable is "created" (a misnomer, humans nor computers can create anything...), some free/unoccupied memory will be marked as "used".
- There are 2 ways to create variables in a high level language:
- Use the new operation (instance variable)
- Enter a new scope (local variable)
(I quote "created" because what actually happens is: memory space immediately following the static variable will be marked as used - there is no real creation going on like that as documented in Genesis 1:1 of the Bible)
- Don't worry if you don't following what I say about creation at this time
- I will explain this concept in more details later in the course
|
|
Later in the course, I will explain why a stack is used when I discuss subroute call and return ( click here )....