ScadMachine Type
A SCAD machine consists of the following components:
-
CU is the control unit which reads move instructions from the program
memory. It is also responsible for branch and jump instructions, and
uses three lanes in its input buffer for this reason:
- CU.inp[0] is the branch condition lane.
- CU.inp[1] is the `then' branch target lane.
- CU.inp[2] is the `else' branch target lane.
- First move the branch target address to CU.inp[1].
- Next, issue move instructions to compute the branch condition.
- Finally, there is move instruction from an output buffer to the CU.inp[0]. If this instruction is issued by the CU, the CU will destroy its CU.pc (making it None), and will move pc+1 to CU.inp[2].
- If CU.inp can fire, a new pc can be taken, and new instructions can be fetched again.
- PU is an array of universal processing units for processing binary
operations. Each PU has one input and one output buffer with the
following lanes:
- PU[i].inp.valEntry[0] holds the left operands of binary operation.
- PU[i].inp.valEntry[1] holds the right operands of a binary operation.
- PU[i].inp.optEntry holds the opcodes and number of copies.
- PU[i].out.valEntry[0] holds the result values.
- The LSU is the load/store unit of the SCAD machine with the
following lanes:
- PU[i].inp.valEntry[0] holds the addresses.
- PU[i].inp.valEntry[1] holds the values to be stored.
- PU[i].inp.optEntry holds the opcodes and number of copies, where opcode true means load and false means store.
- PU[i].out.valEntry[0] holds the result values in case of load operations.
- The ROB is the reorder unit of the SCAD machine that is used by the code generator whenever the operands are not found in the right order in the output buffers. It is one input and one output lane and simply copies the values from the input to the output buffer lane (so it is essentially just an additional buffer).
- MemData is the data memory that can be accessed only by the LSU.
- MemProg is the program memory that can be accessed only by the CU.
- 0: CU
- 1: LSU
- 2: ROB
- 3..n+2: PU for the n universal processing units PU[0..n-1]
Record fields
| Record Field | Description |
|
|
|
|
|
Full Usage:
MemData
Field type: int[]
|
|
|
|
|
|
|
|
|
|
Instance members
| Instance member | Description |
|
checks whether an address can be added to an input buffer
|
|
checks whether an address can be added to an output buffer
|
Full Usage:
this.canEnqValInp (src, tgt)
Parameters:
int * addressBuf
tgt : address
Returns: bool
|
checks whether a value can be added to an input buffer
|
Full Usage:
this.canEnqValOut (arg1, numCopies)
Parameters:
address
numCopies : int
Returns: bool
|
checks whether nc copies of a value can be added to an output buffer
|
Full Usage:
this.canFireInp adrU
Parameters:
int
Returns: bool
|
check whether unit adrU can be fired
|
Full Usage:
this.canFireOut adrU
Parameters:
int
Returns: bool
|
check whether the output buffer of unit adrU can send out a value
|
|
check whether instruction mv can be issued
|
|
add an address to an input buffer if possible |
|
add an address to an output buffer if possible |
|
add a value v to input buffer tgt that shall be sent from buffer src
|
|
add a value to an output buffer |
Full Usage:
this.fireInp adrU
Parameters:
int
Returns: bool
|
Fire a functional unit if possible, i.e., if the input buffer is not empty and all fields in the head's fields are defined. A successful firing is reported as return value.
|
Full Usage:
this.fireOut adrU
Parameters:
int
Returns: bool
|
Fire an output buffer if possible, i.e., sending some produced value to an input buffer of some other functional unit. An output buffer can be fired iff is not empty, all fields in the head's fields are defined, and there is enough space in the input buffer where the value should be sent to. A successful firing is reported as return value.
|
|
issues a move instruction if possible, and reports potential success
|
|
print the buffer entries to output stream
|
|
write the buffer entries as html table to output stream
|