Computer Architecture Lab/WS2006/Group6/ISA

Intel 8085

edit

Memory

edit

Program, data and stack memories occupy the same memory space. The total addressable memory size is 64 KB.

Program memory

edit

program can be located anywhere in memory. Jump, branch and call instructions use 16-bit addresses, i.e. they can be used to jump/branch anywhere within 64 KB. All jump/branch instructions use absolute addressing

Data memory

edit

The processor always uses 16-bit addresses so that data can be placed anywhere.

Stack memory

edit

is limited only by the size of memory. Stack grows downward.

Interrupts

edit

The processor has 5 interrupts – INTR, RST5.5 ,RST6.5 RST7.5 and Trap.

I/O ports

edit

256 Input ports, 256 Output ports

Registers

edit

Accumulator

edit

or A register is an 8-bit register used for arithmetic, logic, I/O and load/store operations.

Flag

edit

8-bit register containing 5 1-bit flags:

  • Sign ,Zero, Parity , Carry set , or borrow during subtraction/comparison.

General registers

edit

8-bit B and 8-bit C registers,8-bit D and 8-bit E registers,8-bit H and 8-bit L registers

Stack pointer

edit

is a 16 bit register. This register is always incremented/decremented by 2.

Program counter

edit

is a 16-bit register.

Instruction Set

edit

Data moving instructions,Arithmetic - add, subtract, increment and decrement,Logic - AND, OR, XOR and rotate,Control transfer - conditional, unconditional, call subroutine, return from subroutine and restarts,Input/Output instructions,Other - setting/clearing flag bits, enabling/disabling interrupts, stack operations, etc.

Addressing modes

edit

Register references the data in a register or in a register pair.
Register indirect - instruction specifies register pair containing address, where the data is located.
Direct Immediate - 8 or 16-bit data.

R8000

edit

Architectural Features of the R8000

edit

The R8000 is a 64bit RISC microprocessor with strong emphasis on floating point performance, that is spcifically designed for supercomputing applications. It implements the MIPS IV instruction set architecture (ISA). The MIPS R8000 processor is designed to deliver extremely high floating point performance. The R8000 key features include:

  • Multi-component chip set consisting of an integer unit (IU), floating-point unit (FPU), tag RAMS, and 2 MB of data streaming cache
  • Four-way superscalar architecture, six operations per clock cycle
  • True 64-bit microprocessor with 64-bit integer and floating-point operations, registers, and virtual addresses
  • 3.3-volt technology
  • 16 KB of instruction cache (I-cache) in IU, 16 KB of dual-ported data cache (D-cache) in IU, 1K entries of branch prediction cache
  • Memory Management Unit (MMU) in IU contains a 384-entry, dual-ported, three-way set associative Translation Lookaside Buffer (TLB)
  • ANSI/IEEE-754 standard floating-point coprocessor with imprecise interrupts
  • 32 doubleword (64-bit) general-purpose registers in IU and 32 floating-point registers in FPU
  • 128-bit data bus and a separate 40-bit address bus that can access up to 1TB of physical memory
  • Upward compatibility with earlier 32-bit and 64-bit MIPS microprocessors
Feature R8000
ISA MIPS IV
Frequency 90 Mhz
Peak MFLOPS 360
Total Number of Instructions per cycle 4
Number of Integer Instructions per cycle 2
Number of Floating Point Instructions per cycle 2
Number of Multiply-Add Instructions per cycle. 2
Number of Load/Store Instructions per cycle 2
Out-of-order Instruction execution No

Instruction set

edit

Instructions are fetched from an on-chip 16-Kbytes instruction cache (Instruction Cache). Four instructions (128 bits) are fetched per cycle.There are three categories of new instructions: fused multiply-add, register+register addressing mode, and conditional moves.The fused multiply-add instructions - three input operands and performs a multiplication followed by an addition with no intermediate rounding. The register+register addressing mode is supported for floating-point loads and stores to enhance the performance of array accesses with arbitrary strides.Integer and memory instructions get their operands from a 13 port register file (Integer Register File).
The R8000 processor includes the following functional units, Integer and memory instructions:

  • 2X load/store
  • 2X ALU
  • 1X shifter
  • 1X integer multiply/divide
  • 2X FPU

The FPU implements the following operations:

  • MADD (1 cycle latency Multiply-Add; ex: a = a + b * c)
  • Divide
  • Square Root
  • Reciprocal (i.e. 1/x)
  • Reciprocal Square Root

Memory

edit

The characteristics of the R8000 memory subsystem - number of ports, sizes and algorithms of the caches, tag RAM, and buffering schemes - complement the high-performance computational capabilities of the R8000 and ensure that memory bandwidth demands from the floating-point and integer units are met.

Pipeline

edit
F D A E W
Intruction fetch aligment precode bench prediction decode scoreboard register file read generate load/store adress ALU data cache TLB lookup branch resolution exception detection regfile write

The Fetch stage - accesses the instruction cache and the branch prediction cache (to be explained later). The Decode stage - makes dispatch decisions based on register scoreboarding and resource reservations, and also reads the register file. The Address stage - computes the effective addresses of loads and stores. The Execute stage - evaluates the ALU operation, accesses the data cache and TLB, resolves branches and handles all exceptions. Finally, the Writeback stage - updates the register file.

EXTERNAL CACHE PIPELINE

edit

There are five stages in the external cache pipeline. Addresses are sent from the R8000 to the tag ram in the first stage. The tags are looked up and hit/miss information is encoded in the second stage. The third stage is used for chip crossing from the tag ram to the data rams. The SSRAM is accessed internally within the chip in the forth stage. Finally data is sent back to the R8000 and R8010 in the fifth stage.

* * * I wandted here to add a picture, but I couldn't register. I also couldn't add a external Picture. 
img src="stud3.tuwien.ac.at/~e0248591/r8000.PNG" ***

AMD Athlon64

edit

It is designed by Advanced Micro Devices (AMD), who have since renamed it AMD64. The AMD64 architecture is a simple yet powerful 64-bit, backward-compatible extension of the industry-standard (legacy) x86 architecture.

Architecture: Pipeline

edit

Pipeline-Stages

  • 20 -. 31 Stages
  • Fetch-Execute
    • it last 20 (31) tacts
  • Pipeline hard to fill


  • TC Nxt = trace cache next instruction pointer
  • TC Fectch = trace cache fetch
  • Rename = register renaming
  • Que = micro-op queuing
  • Sch = micro-op scheduling
  • Disp = dispatch
  • RF = register file
  • Ex = execute
  • Flgs = flags
  • BrCk = branch check

Instruktions-Set

edit

IA-32 (x86) Instruktions-set

  • 32-Bit instructions; 32-Bit Adresses
  • Variable instruction lenght: 1-16 Bytes
  • no Load-Store architecture
    • operand may be on memory
    • instructions can change the memory
  • 2 Adress-instructions
    • target is also the source ADD EAX, [1234]
  • branch instructions
    • check statusbits in Flag-Register
  • different levels
    • Level 0: operating system
    • Level 3: User-Programm

Instructions

edit

x86-Instructions

  • Data transfer instructions (MOV)
  • binary arithmetic (ADD, SUB)
  • logical instructions (AND, OR)
  • shift and rotate (ROR, SAR)
  • bit and byte instructions (BTS, SETE)
  • control transfer instructions (JMP, LOOP, CALL)
  • string instructions (MOVS, SCAS)
  • flag control instructions (STD, STI)
  • segment register instructions (LDS)
  • miscellaneous instructions (LEA, NOP, CPUID)

Instructions format

edit

Complicated and complex size

  • 1-Byte Opcodes
    • originally 1-Byte Opcodes
  • Prefixes possible
    • Other words width or iteration
  • Instructions decoding is difficult
  • ModR/M, SIB, Displacement, Immediate:
    • Operands addressing
    • 24 Adress types
    • Offset = Base + Index*Scale + Displacement

Register

edit

ExX-Register

  • Mixture General-Purpose and Special-Purpose Register
  • EAX: Accumulator
  • EBX: Base-Register
  • ECX: Count-Register
    • Special: Loops
  • EDX: Data-Register
    • Special: multiplication / division

Furthermore

  • EBP: Base-Pointer
    • points out at the Stacks start
  • ESI, EDI: Source- und Destination-Register
  • ESP: Stack-Pointer
  • EFLAGS: Flags

Adressing mode

edit

Addressing: the choise of an instruction operands
– where are the operands stored
Immediate addressing: MOV EAX, 1234
– specifying the data direct instead of adress
Direct addressing: MOV EAX, [1234]
– detail of (32-Bit) memory address
Register-Adressing: MOV EAX, EBX
– Register contain operand
Register-indirect adressing: MOV EAX, [EBX]
– Register contain the adress of operands
– Pointer
Indexed addressing: MOV EAX, table[EBX]
– Basicadress + Offset Register
Indexed Register- indirect addressing with displacement
– IA-32 speciality: MOV EAX, table[EBX*4 + 1]