Me: Brenda - current CS61C TA

Topics:

Intro:

You probably learned this stuff before already, but may have forgotten some.
I will go over the topics in CS GRE relating to CS61C very briefly, if there is any area where it's very vague to you, please stop me and ask for elaboration.
Note I'll still go over some MIPS-specific stuff, but on the GRE they may not ask you MIPS stuff. As long as you get the concepts down, you should be able to handle other instruction set/architectures with no problem.
It's multiple guess anyway! :)

Numbers:

binary (base 2), octal (base 8), decimal (base 10), hex (base 16):
Remember how to convert between these?

sign/magnitude, 1's complement, 2's complement:
S/M: first bit sign, rest magnitude.
1's complement: if number is negative, invert all bits.
2's complement: if number is negative, invert all bits and add 1.

Using n bits, how many numbers can be represented in 2's complement?
Total 2n numbers can be represented.
Half are positive, half are negative.
But remember 0 is first positive number.
=> -2n-1 to 2n-1 - 1

Fixed point: decimal point is fixed

Floating point: IEEE standard:
single precision: 1.8.23
sign: 1 bit, 1 for negative, 0 for positive numbers
exponent: 8 bits, bias of 127
significand: 23 bits, implied 1
value: -1sign * (1.significand) * 2exp-127
special values:

0: all bits 0
denorms: exp 0, significand not 0
infinity: exp 255, significand 0 (division by 0)
Not a Number: exp 255, significan not 0 (0/0, inf/inf)
double precision: 1.11.52, exp bias 1023

Rounding: 4 IEEE options:

up to infinity: always round up
down to -infinity: always round down
truncate: drop the last bits, round towards 0
round to even: normal rounding, but if the value is exactly halfway in between, round to the nearest even number

Overflow and underflow:
overflow: if both numbers are positive and result is negative
underflow: if both numbers are negative and the result is 0 or positive.
saturating arithmetic: instead of rolling over on overflow or underflow, the result is set to be the maximum or minimum possible value.

Harddrive access time


seek time: time required for the head to move to the track where information is to be read or written
latency time: the time it takes the disk to rotate so that the head is located at the beginning of the sector where the information is to be read or written and is the next faster delay period
transmission time:fastest delay period for data transfer because this period does not involve any physical movement

Starting a program

compiler: translates high-level language code to assembly language code
assembler: translates assembly language code to machine code (1's and 0's)
linker: takes one or more binary object files, resolves external references, and produces executable files
loader: loads executable file into memory

Logical operations

bitwise and/or/xor/xnor

Datapath, pipelining, super-scalar, out-of-order execution

pipeline: remember the laundry example!
latency: amount of time it takes for a single piece of data to get from point A to point B. Often refers to the time necessary for the first bit to be transferred.
bandwidth: the sustained rate which we can transfer data from point A to point B. Usually refers to the sustained bandwidth, ignoring latency.
5 pipeline stages in MIPS: instruction fetch, decode, execute, memory, write back
Pipeline hazards: when the current instruction depends on the result of previous instructions, but the previous instructions are still unfinished (in the pipe)!
RAW: read after write - need to forward
WAW: write after write - not a problem if writes always happen in order
WAR: write after read - not a problem if writes always happen in order (after reads)
RAR: read after read - not a problem
load needs to have a stall cycle
super scalar: able to execute many instructions simutaneously
out-of-order execution: used when some operations take longer than others, but notice the instruction issues always happen in order!

System performance

3 factors: Cycles Per Instruction, clock rate, and instruction count
execution time = instr count * CPI * 1/clock rate
performance = 1 / execution time
Amdahl's law: when improving one item, you can only improve the total time by the fraction that task requires.
ie: execution time after improvement = (executime time affected by improvement / amount of improvement) + execution time unaffected
implications: make the common case fast, don't optimize infrequent cases