- Computer memory consists of bytes
- Each bytes is 8 bits (= Binary digITS)
- A bit (binary digit) is the most elementary electrical memory element,
and can remember one of the values:
- 0 or
- 1
(It's an electrical switch: it can be "off" or "on")
- Each byte is identified by an address
- A byte can contain 28 = 256 different values
(but not all 256 values at the same time)
- Sample Memory content:
- Information are stored in computer using
one of several
encoding methods
We will discuss various encoding methods later...
- A byte
can store one of 256 different patterns (values) and
is therefore only large enough to hold values from a small
representation set
(with upto 256 different values in the set)
So a byte can represent only a set that has a small number of distinct values, such as:
- The set of characters
- The set of integers
is
infinite
in size.
The computer will only represent a subset of integers
- A byte
can only represent a subset of integer value
that is of size 256.
Larger memory cells are needed to represent larger value sets of integer values.
- The computer provide several
representations
for (subsets of) integer values:
- 2 consecutive bytes are used to hold values
of "short" integers
(the short type, represents integers [-32767, 32768] or [-(215-1), 215])
- 4 consecutive bytes are used to hold values of
"ordinary integer" integers
(the int type, represents integers [-2147483647, 2147483648] or [-(231-1), 231])
- 8 consecutive bytes are used to hold values of
"long integer" integers
(the long type, represents integers [-9223372036854775807, 9223372036854775808] or [-(263-1), 263])
- 2 consecutive bytes are used to hold values
of "short" integers
- Example Storage:
- 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 tell how many bytes it needs to use in an operation ???
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 allocates an unused portion
of the memory of the proper size (depending on the type of
the variable.
- After allocating 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 allocates an unused portion
of the memory of the proper size (depending on the type of
the variable.
- Later in the program,
when the variable is referenced (used)
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....)
- The computer are initially all
unoccupied ("free")
- When a computer program is
loaded
into the computer memory (for execution),
a portion
of the computer memory will become
occupied
or
reserved
- Computer memory is also used to
store variables (information)
Variables in a program can be "created" (begins to exists) and be "destroyed" (ceases to exists).
- When a new variable is
"created"
(which is a misnomer, humans nor computers
can create anything...), an amount of
(previously)
free/unoccupied memory
will be marked as "USED".
- When a new variable is "destroyed" the memory occupied by the variable will be marked as "UNUSED".