<- previous    index    next ->

Lecture 13, Microprogramming - review


Review is paper handout. (not for online classes, open web)
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.unix.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 note 5 clocks, similar to project

review for midterm, handout

    <- previous    index    next ->

Other links

Go to top