(Indeed, the data is being transfered between an IO device and the memory, and not between IO device and the CPU, because there is no space inside the CPU to hold the vast amount of data that is being transfered.)
- CPU - the CPU is a general purpose processor, i.e., it can do
anything that a machine can do (that's why it's called
"general purpose").
We could make this (very expensive) processor perform the
(relatively simple) transfer operation.
When the CPU performs the IO operation, the technique is called "programmed IO".
- DMA - acronym for "Direct Memory Access", it is actually a specialized processor that can only perform data transfer operations
Programmed IO
Before I can show you exactly what happens in programmed IO, I need to make some assumptions about the computer system...
The following are the assumptions for the computer system:
- I will use M68000 to illustrate
- M68000 uses memory mapped IO
- I will use a printer as the example IO device
- I will assume that the printer interface has 3 registers
and they are mapped into the following addresses:
- Status register: address 2000
- Command register: address 2004
- Data register: address 2008
Schematically:
To put things in perspective:
- an IO operation to the printer (or terminal)
can be initiated by the program statement as the following:
(Assume String myString = "ABCDEFGHIJ";) System.output.print(myString);
If the computer system uses programmed IO, the program statement "System.output.print(myString)" will generate an assembler program that instruct the CPU to do the IO communication with the intended IO device (in this case, the printer).
The Java statement:
System.output.print(myString)(assume variable myString = "ABCDEFGHIJ";) will translate into the following assembler program that prints the (10) characters in the variable "myString" to the printer:
* Memory address 2000 = status register of printer
* Memory address 2004 = data register of printer
* Memory address 2008 = command register of printer
move.l #myString, A0 // A0 points to the
first character in myString
move.l #10, D0 // D0 = count
Loop:
move.l 2000, D1 // Read printer status
cmp.l #0, D1 // Check if printer is idle
bne Loop // Wait until printer is idle
before you can send the next
character to printer
// Now the printer status = idle...
move.b (A0), 2004 // Send next character to be printer
move.l #1, 2008 // Tell printer to print
adda.l #1, A0 // Make A0 point to next character
in myString
sub.l #1, D0
cmp.l #0, D0 // Check if all characters printed...
bne Loop // Loop if not done...
....
myString: dc.b 'ABCDEFGHIJ' // The ASCII codes of the string
- Do not require any additional hardware
- Is appropriate when the CPU cycles can be wasted liberally - that would be the case when you are installing a new Operating System (like Windows 98, 2000, ME, Linux, etc) into your PC
- The performance sucks: the CPU is spending most of the time doing
nothing but wait.
- In fact, it is not very smart to make the CPU perform the IO
(unless the CPU has nothing else better to do, such as the case when
are installing a new operating system):
- The CPU is the most expensive piece of hardware in
the whole computer and can do anything, e.g., it can compute
Pi to millions of decimals if you want it to.
- Instead of performing complex operations, the CPU in programmed IO spends most of the time testing if the printer is idle and once a while move a byte of data from memory to the printer's data register. This is a simple minded task that can be accomplished by a much much much more simpler processor.
- The CPU is the most expensive piece of hardware in
the whole computer and can do anything, e.g., it can compute
Pi to millions of decimals if you want it to.
BUT... in doing so, we create two new problems...
We will see this next...