<- previous index next ->
Review is paper handout and overhead projector.
Following, microcontrollers, microprogramming and 64-bit.
A microcontroller may be a very small and inexpensive device.
The basic parts are Combinational Logic, logic gates, and some
type of storage, Sequential Logic.
For students who have taken CMSC 451, this is the classic
Deterministic Automata, a Finite State Machine.
A microcontroller may have Read Only Memory, ROM, that contains
a microprogram to run the microcontroller. Micro assemblers and
micro compilers may be used to generate the microprogram. The
microprogram is manufactured in the microcontroller.
Micro instructions may be very long, 40 to 64 bits is common.
Often there are bits to directly control multiplexors.
Often there are groups of bits to directly control other
units such as the ALU.
There may be bits that go directly to outputs.
Every microinstruction may have a jump address.
The jump may be a conditional branch based on some state bits.
From Wikipedia wiki/Microcode
Terminology: Combinational Logic is just gates. No storage.
Sequential Logic has storage, flipflop(s) or register(s).
A flipflop or register holds the output until changed.
A flipflop or register will have a clock and data
will only be input to change state on a clock edge.
There may be a clear or set input that does not
need a clock signal, typically used to initialize
a logic circuit to a known state.
This lecture also covers 64-bit machines (If not covered earlier)
A 64-bit architecture, by definition, has 64-bit integer registers.
Many computers have had 64-bit IEEE floating point for many years.
The 64-bit machines have been around for a while as the Alpha and
PowerPC yet have become popular for the desktop with the Intel and
AMD 64-bit machines.
Software has been dragging well behind computer architecture.
The chaos started in 1979 with the following "choices."
The full whitepaper www.1.org/whitepapers/64bit.html
My desire is to have the compiler, linker and operating system be ILP64.
All my code would work fine. I make no assumptions about word length.
I use sizeof(int) sizeof(size_t) etc. when absolutely needed.
On my 8GB computer I use a single array of over 4GB thus the subscripts
must be 64-bit. The only option, I know of, for gcc is -m64 and that
just gives LP64. Yuk! I have to change my source code and use "long"
everywhere in place of "int". If you get the idea that I am angry with
the compiler vendors, you are correct!
Here are sample programs and output to test for 64-bit capability in gcc:
Get sizeof on types and variables big.c
output from gcc -m64 big.c big.out
malloc more than 4GB big_malloc.c
output from big_malloc_mac.out
Newer Operating Systems and compilers
Get sizeof on types and variables big12.c
output from gcc big12.c big12.out
The early 64-bit computers were:
DEC Alpha
DEC Alpha
IBM PowerPC
<- previous index next ->