Clocks 1 A clock is a free-running signal with a cycle time. A clock may be either high or low, and alternates between the two states. The length of time the clock is high before changing states is its high duration; the low duration is defined similarly. The cycle time of a clock is the sum of its high duration and its low duration. The frequency of the clock is the reciprocal of the cycle time. rising edge falling edge high low time State Elements 2 A state element is a circuit component that is capable of storing a value. At the moment, we are interested primarily in state elements that store logical state information about the system, rather than data storage. A state element may be either unclocked or clocked. Clocked state elements are used in synchronous logic - When should an element that contains state be updated? - Edge-triggered clocking means that the state changes either on the rising or the falling edge. - Clock edge acts as a sampling signal that triggers the update of a state element. A signal that is to be written into a state element must be stable; i.e., it must be unchanging. If a function is to be computed in one clock cycle, then the clock period must be long enough to allow all the relevant signals to become stable.
An Unclocked State Element The set-reset (SR) latch - output depends on present inputs and also on past inputs 3 Latches and Flip-flops Output is equal to the stored value inside the element 4 Assume clocked state elements are used: latch: state changes whenever the inputs change, and the clock is asserted flip-flop: state changes only on a clock edge "logically true", could mean electrically low A clocking methodology defines when signals can be read and written wouldn't want to read a signal at the same time it was being written
Clocked -latch Two inputs: - he data value to be stored () - the clock signal indicating when to read and store Two outputs: - the value of the internal state () and its complement 5 C Clocked Flip-flop Here s a schematic for a flip-flop with a falling edge trigger: 6 C latch C latch C Here s a timing diagram illustrating the behavior of the circuit above: C
Our Implementation An edge triggered methodology Typical execution: - read contents of some state elements, - send values through some combinational logic - write results to one or more state elements 7 State element 1 Combinational logic State element 2 Clock cycle 4-Bit Register Built using flip-flops: 8 Clock input controls when input is "written" to the individual flip-flops. However, the design above isn t quite what we want TP What s wrong with this? How can we fix it?
Register File 9 A register file is a collection of k registers (a sequential logic block) that can be read and written by specifying a register number that determines which register is to be accessed. The interface should minimally include: - an n-bit input to import data for writing (a write port) - an n-bit output to export read data (a read port) - a log(k)-bit input to specify the register number - control bit(s) to enable/disable read/write operations - a control bit to clear all the registers, asynchronously - a clock signal Some designs may provide multiple read or write ports, and additional features. For MIPS, it is convenient to have two read ports and one write port. Why? A File of 4-Bit Registers 10 Aggregating a collection of 4-bit registers, and providing the appropriate register selection and data input/output interface: 4-bit registers decoder to select write register multiplexor to select read register
Random Access 11 Random access memory (RAM) is an array of memory elements. Static RAM (SRAM): - bits are stored as flip-flops (typically 4 or more transistors per bit) - hence static in the sense that the value is preserved as long as power is supplied - somewhat complex circuit per bit, so not terribly dense on chip - typically used for cache memory ynamic RAM (RAM): - bits are stored as a charge in a capacitor - hence dynamic since periodic refreshes are needed to maintain stored values - single transistor needed per data bit, so very dense in comparison to SRAM - much cheaper per bit than SRAM - much slower access time than SRAM - typically used for main memory Basic MIPS Implementation 12 Here's an updated view of the basic architecture needed to implement a subset of the MIPS environment: RAM modules register file
SRAMs 13 Configuration specified by the # of addressable locations (# of rows or height) and the # of bits stored in each location (width). Consider a 4M x 8 SRAM: - 4M locations, each storing 8 bits - 22 address bits to specify the location for a read/write - 8-bit data output line and 8-bit data input line Enable/disable chip access 21-bit address input 16-bit output path Enable/disable read and write access 16-bit wide input path SRAM Performance 14 read access time - the delay from the time the Output enable is true and the address lines are valid until the time the data is on the output lines. - typical read access times might be from 2-4 ns to 8-20 ns, or considerably greater for low-power versions developed for consumer products. write access time - set-up and hold-time requirements for both the address and data lines - write-enable signal is actually a pulse of some minimum width, rather than a clock edge - write access time includes all of these
SRAM Implementation 15 Although the SRAM is conceptually similar to a register file: - impractical to use same design due to the unreasonable size of the multiplexors that would be needed - design is based on a three-state buffer output enable multiplexor build from 3- state buffer elements data signal If output enable is 1, then the buffer's output equals its input data signal. If output enable is 0, then the buffer's output is in a high-impedance state that effectively disables its effect on the bit line to which it is connected. SRAM Implementation 16 At right is a conceptual representation of a 4x2 SRAM unit built from latches that incorporate 3-state buffers. For simplicity, the chip select and output enable signals have been omitted. Although this eliminates the need for a multiplexor, the decoder that IS required will become excessively large if we scale this up to a useful capacity.
SRAM Implementation 17 A 4Mx8 SRAM as an array of 4Kx1024 arrays: decoder generates addresses for the 4096 rows of each of the 8 subarrays each subarray outputs a row of 1024 bits bank of 10-bit multiplexors select one bit from each of the subarrays This requires neither a huge multiplexor nor a huge decoder. A practical version might use a larger number of smaller subarrays. How would that affect the dimensions of the decoder and multiplexors that would be needed? RAM Implementation 18 Each bit is stored as a charge on a capacitor. Periodic refreshes are necessary and typically require 1-2% of the cycles of a RAM module. Access uses a 2-level decoding scheme; a row access selects and transfers a row of values to a row of latches; a column access then selects the desired data from the latches. Refreshing uses the column latches. RAM access times typically range from 45-65 ns, about 5-10 times slower than typical SRAM.
Error etection 19 Error detecting codes enable the detection of errors in data, but do not determine the precise location of the error. - store a few extra state bits per data word to indicate a necessary condition for the data to be correct - if data state does not conform to the state bits, then something is wrong - e.g., represent the correct parity (# of 1 s) of the data word - 1-bit parity codes fail if 2 bits are wrong 1011 1101 0001 0000 1101 0000 1111 0010 1 odd parity: data should have an odd number of 1's A 1-bit parity code is a distance-2 code, in the sense that at least 2 bits must be changed (among the data and parity bits) produce an incorrect but legal pattern. In other words, any two legal patterns are separated by a distance of at least 2. Error Correction 20 Error correcting codes provide sufficient information to locate and correct some data errors. - must use more bits for state representation, e.g. 6 bits for every 32-bit data word - may indicate the existence of errors if up to k bits are wrong - may indicate how to correct the error if up to l bits are wrong, where l < k - c code bits and n data bits 2 c >= n + c + 1 We must have at least a distance-3 code to accomplish this. Given such a code, if we have a data word + error code sequence X that has 1 incorrect bit, then there will be a unique valid data word + error code sequence Y that is a distance of 1 from X, and we can correct the error by replacing X with Y.
Error Correction 21 A distance-3 code is also knows as a single-error correcting, double-error correcting or SECE code. If X has 2 incorrect bits, then we will replace X with an incorrect (but valid) sequence. We cannot both detect 2-bit errors and correct 1-bit errors with a distance-3 code. But, hopefully flipped bits will be a rare occurrence and so sequences with two or more flipped bits will have a negligible probability. Hamming Codes 22 Richard Hamming described a method for generating minimum-length error-correcting codes. Here is the (7,4) Hamming code for 4-bit words: Say we had the data word 0100 and check bits 011. The two valid data words that match that check bit pattern would be 0001 and 0110. The latter would correspond to a single-bit error in the data word, so we would choose that as the correction. Note that if the error was in the check bits, we'd have to assume the data word was correct (or else we have an uncorrectable 2-bit error or worse). In that case, the check bits would have to be 1 bit distance from 110, which they are not. ata bits 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 Check bits 000 011 101 110 110 101 011 000 111 100 010 001 001 010 100 111
Hamming Code etails 23 Hamming codes use extra parity bits, each reflecting the correct parity for a different subset of the bits of the code word. Parity bits are stored in positions corresponding to powers of 2 (positions 1, 2, 4, 8, etc.). The encoded data bits are stored in the remaining positions. The parity bits are defined as follows: - position 1: check 1 bit, skip 1 bit, check 1 bit, skip 1 bit, - position 2: check 2 bits, skip 2 bits, - position 2 k : check 2 k bits, skip 2 k bits, Consider the data byte: 10011010 Expand to allow room for the parity bits: 1 _ 001_1010 Now compute the parity bits as defined above Hamming Code etails 24 We have the expanded sequence: 1 _ 0 0 1 _ 1 0 1 0 The parity bit in position 1 (first bit) would depend on the parity of the bits in positions 1, 3, 5, 7, etc: 1 _ 0 0 1 _ 1 0 1 0 Those bits have even parity, so we have: 0 _ 1 _ 0 0 1 _ 1 0 1 0 The parity bit in position 2 would depend on bits in positions 2, 3, 6, 7, etc: 0 _ 1 _ 0 0 1 _ 1 0 1 0 Those bits have odd parity, so we have: 0 1 1 _ 0 0 1 _ 1 0 1 0 Continuing, we obtain the encoded string: 0 1 1 1 0 0 1 0 1 0 1 0
Hamming Code Correction 25 Suppose we receive the string: 0 1 1 1 0 0 1 0 1 1 1 0 How can we determine whether it's correct? Check the parity bits and see which, if any are incorrect. If they are all correct, we must assume the string is correct. Of course, it might contain so many errors that we can't even detect their occurrence, but in that case we have a communication channel that's so noisy that we cannot use it reliably. Checking the parity bits above: 0 1 1 1 0 0 1 0 1 1 1 0 OK WRONG OK WRONG So, what does that tell us, aside from that the string is incorrect? Well, if we assume there's no more than one incorrect bit, we can say that because the incorrect parity bits are in positions 2 and 8, the incorrect bit must be in position 10.