CPSC 213 for Java and C programs you will trace, write, read load - PowerPoint PPT Presentation

The Big Picture Languages and Tools Lab/Assignment 1 ‣ Build machine model of execution ‣ SM213 Assembly ‣ SimpleMachine simulator CPSC 213 • for Java and C programs •you will trace, write, read •load code into Eclipse and get it to build/run • by examining language features •use SM213 simulator to trace and execute •write and test MainMemory.java • and deciding how they are implemented by the machine ‣ Java -get ‣ What is required -set •you will read, write -isAccessAligned • design an ISA into which programs can be compiled •use Eclipse IDE to edit, compile, debug, run -bytesToInteger • implement the ISA in Java in the hardware simulator •SM213 simulator written in Java; you will implement specific pieces -integerToBytes Introduction to Computer Systems ‣ Our approach ‣ C • examine code snippets that exemplify each language feature in turn •you will read, write • look at Java and C, pausing to dig deeper when C is different from Java Unit 1a •gcc to compile, gdb to debug, command line to run • design and implement ISA as needed Numbers and Memory ‣ The simulator is an important tool • machine execution is hard to visualize without it • this visualization is really our WHOLE POINT here 1 2 3 4 The Main Memory Class The Code You Will Implement ** /** * Fetch a sequence of bytes from memory. * Convert an sequence of four bytes into a Big Endian integer. * @param address address of the first byte to fetch * @param byteAtAddrPlus0 value of byte with lowest memory address ‣ The SM213 simulator has two main classes * @param length number of bytes to fetch * @param byteAtAddrPlus1 value of byte at base address plus 1 /** * @return an array of UnsignedByte * @param byteAtAddrPlus2 value of byte at base address plus 2 * Determine whether an address is aligned to specified length. */ •CPU implements the fetch-execute cycle * @param byteAtAddrPlus3 value of byte at base address plus 3 * @param address memory address protected UnsignedByte[] get (int address, int length) throws ... { •MainMemory implements memory * @param length byte length * @return Big Endian integer formed by these four bytes UnsignedByte[] ub = new UnsignedByte [length]; * @return true iff address is aligned to length */ ub[0] = new UnsignedByte (0); // with appropriate value ‣ The first step in building our processor */ public int bytesToInteger (UnsignedByte byteAtAddrPlus0, // repeat to ub[length-1] ... protected boolean isAccessAligned (int address, int length) { UnsignedByte byteAtAddrPlus1, return ub; •implement 6 main internal methods of MainMemory UnsignedByte byteAtAddrPlus2, return false; } UnsignedByte byteAtAddrPlus3) { } return 0; /** CPU MainMemory } * Store a sequence of bytes into memory. fetch read isAligned * @param address address of the first memory byte /** readInteger * @param value an array of UnsignedByte values execute bytesToInteger * Convert a Big Endian integer into an array of 4 bytes * @throws InvalidAddressException if any address is invalid write integerToBytes * @param i an Big Endian integer */ writeInteger get * @return an array of UnsignedByte protected void set (int address, UnsignedByte[] value) throws ... { */ byte b[] = new byte [value.length]; set public UnsignedByte[] integerToBytes (int i) { for (int i=0; i<value.length; i++) b[i] = (byte) value[i].value(); return null; // write b into memory ... } } 5 6 7 8 Reading Binary, Hex, and Decimal Refresher Bit Shifting B H D ‣ Companion ‣ Hexadecimal notation 0000 0 0 ‣ bit shifting: multiply/divide by powers of 2 0001 1 1 ‣ left shift by k bits, "<< k": multiply by 2 k •previous module: 1, 2.1 •number starts with “0x” , each digit is base 16 not 0010 2 2 base 10 • old bits on left end drop off, new bits on right end set to 0 •new: 2.2 (focus on 2.2.2 for this week) 0011 3 3 •e.g.: 0x2a3 = 2x16 2 + 10x16 1 + 3x16 0 • examples ‣ Textbook 0100 4 4 - 0000 1010 << 1 = 0001 0100; 0x0a << 1 = 0x14; 10 << 1 = 20; 10 * 2 = 20 •a convenient way to describe numbers when 0101 5 5 • A Historical Perspective, Machine-Level Code, Data Formats, Data - 0000 1110 << 2 = 0011 1000; 0x0e << 2 = 0x38; 14 << 2 = 28; 14 * 4 = 56 binary format is important Numbers and Bits 0110 6 6 • << k, left shift by k bits, multiply by 2 k Alignment. •each hex digit (hexit) is stored by 4 bits: - old bits on left end drop off, new bits on right end set to 0 0111 7 7 •2ed: 3.1-3.2.1, 3.3, 3.9.3 (0|1)x8 + (0|1)x4 + (0|1)x2 + (0|1)x1 ‣ right shift by k bits, ">> k": divide by 2 k 1000 8 8 - (skip 3.2.2 and 3.2.3) ‣ Examples 1001 9 9 • old bits on right end drop off, new bits on left end set to 0 •1ed: 3.1-3.2.1, 3.3, 3.10 1010 a 10 - (in C etc... stay tuned for Java!) •0x10 in binary? in decimal? • examples 1011 b 11 •0x2e in binary? in decimal? - 1010 >> 1 = 0101 1100 c 12 - 1110 >> 2 = 0011 •1101 1000 1001 0110 in hex? in decimal? 1101 d 13 ‣ why do this? two good reasons: •102 in binary? in hex? 1110 e 14 • much faster than multiply. much, much faster than division 1111 f 15 • good way to move bits around to where you need them 9 10 11 12 Masking Two's Complement: Reminder Two's Complement: Byte Two's Complement: 32-Bit Integers B H Signed Decimal Unsigned ‣ bitmask: pattern of bits you construct with/for logical ‣ unsigned ‣ unsigned 1111 1111 0xff -1 255 operations 1111 1110 0xfe -2 254 •all possible values interpreted as positive numbers •all possible values interpreted as positive numbers 0 255 1111 1101 0xfd -3 253 0 4,294,967,295 •mask with 0 to throw bits away •byte (8 bits) •int (32 bits) 1111 1100 0xfc -4 252 •mask with 1 to let bit values pass through 1111 1011 0xfb -5 251 ‣ masking in binary: remember your binary truth tables! 0x0 0xff 0x0 0xffffffff 1111 1010 0xfa -6 250 ‣ signed: two's complement ‣ signed: two's complement •&: AND, |: OR 1111 1001 0xf9 -7 249 1111 1000 0xf8 -8 248 •1&1=1, 1&0=0, 0&1=0, 0&0=0 •the first half of the numbers are positive, the second half are negative •the first half of the numbers are positive, the second half are negative 1111 0111 0xf7 -9 247 •1|1=1, 1|0=1, 0|1=1, 0|0=0 •start at 0, go to top positive value, "wrap around" to most negative value, •start at 0, go to top positive value, "wrap around" to most negative value, 1111 0110 0xf6 -10 246 end up at -1 end up at -1 •example: 1111 & 0011 = 0011 1111 0101 0xf5 -11 245 ‣ masking in hex: -128 -1 0 +127 -2,147,483,648 -1 0 2,147,483,647 1111 0100 0xf4 -12 244 1111 0011 0xf3 -13 243 •mask with & 0 to turn bits off 1111 0010 0xf2 -14 242 •mask with & 0xf (1111 in binary) to let bit values pass through 1111 0001 0xf1 -15 241 0x80 0xff 0x0 0x7f 0x80000000 0xffffffff 0x0 0x7fffffff •example: 0x00ff & 0x3a2b = 0x002b 1111 0000 0xf0 -16 240 13 14 15 16