FALL 2017 CSCI 304 LAB2 (Due on October-10, 11:59:59pm)

Transcription

1 FALL 2017 CSCI 304 LAB2 (Due on October-10, 11:59:59pm) OBJECTIVES: Manipulating Bits REMINDERS: Ø Every lab requires a README file. This file should include the following: o Student name(s) - to avoid the 10% deduction (as explained in the course syllabus) o Effort distribution for each contributor (assumed 100% if you are not working with a partner) o Total amount of time to complete the entire lab o Short description of any concerns, interesting problems or discoveries encountered, or comments in general about the contents of the lab o Directions on how to run the solution(s), as needed Ø You should aim to always hand an assignment in on time. If you are late (even by a minute or heaven forbid, less than a minute late), you will receive 50% of your earned points for the designated grade as long as the assignment is submitted by 11:59pm the following day, based on the due date listed on the syllabus and confirmed by the instructor. If you are more than 24 hours late, you will receive a zero for the assignment and your assignment will not be graded at all. Ø Any lab submitted that does not compile and run WILL RECEIVE AN AUTOMATIC GRADE OF ZERO. No exceptions will be made for this rule - to achieve even a single point on a lab your code must minimally compile and execute without crashing. Ø You are welcome to do more than what is required by the assignment as long as it is clear what you are doing and it does not interfere with the mandatory requirements. Ø You are responsible for making sure that your lab submits correctly. Ø Be sure that you are aware of the Coding Style file information posted on my Day by Day website. LAB DESCRIPTION Introduction The purpose of this assignment is to become more familiar with bit- level representations and manipulations. You ll do this by solving a series of programming puzzles. Many of these puzzles are artificial, but you ll find yourself thinking much more about bits in working your way through them. Project Instructions Any clarifications and revisions to the assignment will be posted on the course Web page. Start by copying datalab- handout.tar from my directory (on our lab machine/server) to a (protected) directory in which you plan to do your work. See the following commands.

2 mkdir cs304 cd cs304 chmod og- rwx. mkdir lab2 cd lab2 cp /home/f85/bren/software/lab2/datalab- handout.tar. # previous command will depend on location of the tar file will create a protected directory and move your source into this directory. Then give the command: tar xvf datalab- handout.tar This will cause 9 files to be unpacked into the directory: README- Instruts, Makefile, bits.h, btest.h, bits.c, btest.c, decl.c, dlc, and tests.c. The only file you will be modifying and turning in is bits.c. The file btest.c allows you to evaluate the functional correctness of your code. The file README- Instruts contains additional documentation about btest. Use the command make btest to generate the test code. Run the test code with the command./btest. Looking at the file bits.c you ll notice a C structure student into which you should insert the requested identifying information about you (your name and login id). If you are working in pairs, please specify only one s identifying information here, and put both of your information into README file. The btest test program will not run until you make this change. The bits.c file also contains a skeleton for each of the 17 programming puzzles. Your assignment is to complete each function skeleton, except the last one, using only straightline code (i.e., no loops or conditionals) and a limited number of C arithmetic and logical operators. Specifically, you are only allowed to use the following eight operators (see operators operator meaning! logical NOT ~ bitwise NOT & bitwise AND ^ bitwise XOR bitwise OR + addition << left shift >> right shift Allowable Operators A few of the functions further restrict this list, and there are several other general restrictions on the assignment. See the comments in bits.c for detailed rules and a discussion of the desired coding style. Solving these 17 puzzles will require fluent familiarity with the seven operators given in the table above. You would be well- advised to read carefully the corresponding

3 operations in operators A very useful tip for this project: The right shift operation (>>) Right shifting an unsigned quantity always fills vacated bits with zero (logical shift). Right shifting a signed quantity will fill with sign bits ("arithmetic shift") on our department machine. For example, the following will print out: x>>31=0xffffffff, y>>31=0x1, 0x >>31=0x1 a>>31=0x0, b>>31=0x0, 0x >>31=0x0 #include <stdio.h> int main() { int x = 0x , a=0x ; unsigned int y = 0x , b=0x ; printf("x>>31=0x%x, y>>31=0x%x, 0x >>31=0x%x\n", x>>31,y>>31, 0x >>31); printf("a>>31=0x%x, b>>31=0x%x, 0x >>31=0x%x\n", a>>31,b>>31, 0x >>31); return 0; } PLEASE READ THE HINTS IN THE END OF THIS PAGE FIRST. Evaluation Your code will be compiled with gcc and run and tested on one of the departmental Linux workstations. Your score will be computed out of a maximum of 84 points based on the following distribution: Correctness of code running on one of the class machines. Performance of code, based on number of operators used in each function. Style points, based on your instructor s subjective evaluation of the quality of your solutions and your comments. The 17 puzzles you must solve have been given a difficulty rating between 1 and 4, such that their weighted sum totals to 44. We will evaluate your functions using the test arguments in btest.c. You will get full credit for a puzzle if it passes all of the tests performed by btest.c, half credit if it fails one test, and no credit otherwise. Regarding performance, the main concern at this point in the course is that you can get the right answer. However, we want to instill in you a sense of keeping things as short and simple as you

4 can. Furthermore, some of the puzzles can be solved by brute force, but we want you to be more clever. Thus, for each function there is a maximum number of operators that you are allowed to use to implement that function. This limit is very generous and is designed only to catch egregiously inefficient solutions. You will receive two points for each function that satisfies the operator limit. Finally, 6 points are reserved for a subjective evaluation of the style of your solutions and your commenting. Your solutions should be as clean and straightforward as possible. Your comments should be informative, but they need not be extensive. Any function you attempt to solve that has no comments will be penalized. Part I: Bit manipulations Name Description Rating Max Ops bitand(x,y) Return (x&y) using only ~ and 1 8 copylsb() Return word with all bits set to 2 5 the least significant bit of x getbyte(x,n) Extract byte n from word x 2 6 isequal(x,y) Return 1 if x == y and 0 otherwise 2 5 bitmask(lowbit,highbit) Return a mask consisting of 1 s between 3 16 lowbit and highbit and zeros elsewhere reversebytes(x) Reverse the bytes of x 3 25 bang(x) Compute!x without using! 4 12 leastbitpos(x) Return a mask that marks the least 4 6 significant 1- bit of x Table 1: Bit- Level Manipulation Functions. Table 1 describes a set of functions that manipulate and test sets of bits. The Rating field gives the difficulty rating (the number of points) for the puzzle, and the Max ops field gives the maximum number of operators you are allowed to use to implement each function. Function bitand computes the AND function. That is, when applied to arguments x and y, it returns (x&y). You may only use the operators and ~. Function copylsb(x) returns the word with all bits set to the least significant bit of x. For example, the copylsb(5) call should return 0xffffffff, and the copylsb(6) call should return 0x Function getbyte(x,n) returns byte number n of x. Byte 0 is the least significant byte and byte 3 is the most significant byte. For example, the getbyte(0x ,0) call should return 0x78, and the getbyte(0x ,2) call should return 0x34. Function isequal(x,y) returns 1 if x == y and 0 otherwise.

5 Function bitmask(highbit,lowbit) returns a mask that is 1 between lowbit and highbit, inclusive, and is 0 elsewhere. You may assume that lowbit and highbit are both greater than or equal to 0 and less than or equal to 31. If lowbit > highbit, then the returned mask should be all zero. For example, the call bitmask(5,3) should return 0x (= ) (the rightmost bit is bit number 0). Function reversebytes(x) returns an int whose bytes are in the reverse order of the bytes of x. For example, the reversebytes(0x ) call should return 0x Function bang(x) returns!x without the use of the! operator. For example, bang(5) should return 0, and bang(0) should return 1. Function leastbitpos(x) returns a mask marking the least significant 1- bit of x. For example, the call leastbitpos(0x60) should return 0x (note that 0x60 = and that 0x20 = ). Part II: Two s Complement Arithmetic Name Description Rating Max Ops minusone(void) Returns a value of - 1 without using tmax(void) Return the maximum 32- bit two s 1 4 complement integer 0x7fff ffff fitsbits(x,n) Return 1 if x fits in an n- bit two s complement int, 2 15 otherwise, return 0 addok(x,y) Return 1 if x+y can be computed 3 20 without overflow, otherwise, return 0 isgreater(x,y) Returns 1 if x is greater than y; 3 24 otherwise, returns 0. IsNegative(x) Return 1 if x < 0, otherwise return multfiveeights(x) Returns the product of x and 5/8, rounded toward sm2tc(x) Interprets x as a sign- magnitude integer 4 15 and returns the value of x as a two s complement integer Table 2: Arithmetic Functions Table 2 describes a set of functions that make use of the two s complement representation of integers. Function minusone returns - 1 without using the minus operator. Function tmax returns the largest positive 32- bit two s complement int, namely 0x7fff ffff. Function fitsbits(x,n) returns 1 if its leftmost parameter x can be represented as an n- bit two s complement integer. You may assume that the number of bits n satisfies 1 n 32. For example, fitsbits(5,3) = 0, since 5 cannot be represented in 3 bits (the largest 3- bit positive number is 3), and fitsbits(- 4,3) = 1, since - 4 can be represented in 3 bits as 100 (it s the 3- bit TMin).

6 Function addok(x,y) returns 1 if the sum x+y can be computed without overflow; otherwise, it returns 0. For example, addok(0x , 0x ) = 0 addok(0x , 0x ) = 1 Function isgreater(x,y) returns 1 if x > y, otherwise, it returns 0. Function isnegative(x) returns 1 if x is negative; otherwise, it returns 0. Function multfiveeights(x) returns the product of x and 5/8, rounded toward 0, without causing overflow. For example, multfiveeights(77) = 48, and multfiveeights(- 22) = Function sm2tc(x) interprets its argument x as a sign- magnitude integer and returns the corresponding two s complement value. In the sign- magnitude number system, the leftmost bit is the sign bit 1 for negative and 0 for non- negative), and the remaining 31 bits give the magnitude (or absolute value) of the integer. The following table gives several sign- magnitude examples: Part III: Floating- Point Operations decimal hex sign magnitude 10 0x a x a - 0 0x x For this part of the assignment, you will implement some common single- precision floating- point operations. In this section, you are allowed to use standard control structures (conditionals, loops), and you may use both int and unsigned data types, including arbitrary unsigned and integer constants. You may not use any unions, structs, or arrays. Most significantly, you may not use any floating point data types, operations, or constants. Instead, any floating- point operand will be passed to the function as having type unsigned, and any returned floating- point value will be of type unsigned. Your code should perform the bit manipulations that implement the specified floating point operations. Table 3 describes a set of functions that operate on the bit- level representations of floating- point numbers. Refer to the comments in bits.c and the reference versions in tests.c for more information. Return bit- level equivalent of expression (float) x. Result is returned as unsigned int, but it is to be interpreted as the bit- level representation of a single- precision floating point values. For exmaple, float_i2f(1) should return 0x3f because 0x3f is the floating point representation of 1 = 1.0 * 2 0. Name Description Rating Max Ops float_i2f(x) Compute (float) x 4 30 Table 3: Floating- Point Functions.

7 The included program fshow helps you understand the structure of floating point numbers. To compile fshow, switch to the handout directory and type: unix> make You can use fshow to see what an arbitrary pattern represents as a floating- point number: unix>./fshow Floating point value e+36 Bit Representation 0x7c000000, sign = 0, exponent = f8, fraction = Normalized X 2^(121) You can also give fshow hexadecimal and floating point values, and it will decipher their bit structure. Submission Instructions Make sure you have included your identifying information in your files bits.c and README. To submit your bits.c and README files, type: make submit This target in the makefile first strips out the printf statements in your bits.c file, then invokes the submit program to submit both of your bits.c and README files. The submission can be repeated as many times as you wish. Only the most recently submitted version is retained. Backing Up Your Source Code Nothing is more frustrating that accidentally deleting a file that you have to hand in. To avoid this frustration, you should back up your source code regularly (such as, before you begin each editing session) with the command: make backup As you can see in the Makefile, the backup target creates a compressed tar file named backup.tar.gz that contains the Makefile and the files of the directory containing the Makefile having.c and.h suffixes. If you ever need to retrieve any of the backed up information, then type

8 gunzip - f backup.tar.gz; tar fxv backup.tar This will create a subdirectory of the current directory having the same name as the current directory where the files from the tar file are placed. For example, if your working directory is./lab1, then the tar fxv backup.tar command will extract the backed up files into a subdirectory./lab1/lab1. You can recover the files that you want from this subdirectory You should read the following hints: Advice You are expected to do your code development on one of the Linux workstations in M- S 121. Make sure that the version of bits.c that you turn in compiles and runs correctly on one of these machines. If you are accustomed to programming in C++ or Java, then programming in C will require a small adjustment from you. Unlike Java or C++, all variables that you use in a procedure must be declared at the beginning of the procedure. Your primary debugging tool will be the printf statement. For example, if you want to know the hexadecimal value of your int variable myvar, then insert the statement printf("%08x\n",myvar); where you want to check the variable s value. The %08x format specifies 8- column hexadecimal output with leading zeros, if necessary (see K&R, p. 153 for more information). A useful fact that you already know needs to be emphasized here, because you may be able to use it in several places: For a variable int x, the expression x>>31 is 0xffffffff if x < 0 and 0x if x 0. The dlc program, a modified version of an ANSI C compiler, will be used to check your programs for compliance with the coding style rules. Type dlc - help to display all of its options. This help output will show you, for example, that you can use dlc to measure the operator counts of your functions by executing the command:./dlc - e bits.c The dlc compiler balks at the #include <stdio.h> preprocessor statement, so do not include it, even though gcc will complain about printf being undeclared when you invoke make. Check the file README for documentation on running the btest program. You ll find it helpful to work through the functions one at a time, testing each one as you go. You can use the - f flag to instruct btest to test only a single function, e.g.,./btest - f addok.

9 Be sure to read carefully the comments at the top of the bits.c file. Note in particular that you cannot use in your code any constant larger than 0xff. Function bitmask(highbit,lowbit) returns a mask that is 1 between lowbit and highbit, inclusive, and is 0 elsewhere. You may assume that lowbit and highbit are both greater than or equal to 0 and less than or equal to 31. If lowbit > highbit, then the returned mask should be all zero. For example, the call bitmask(5,3) should return 0x (= ) (the rightmost bit is bit number 0). You can see bit 3,4,5 are all 1's. Hint: Some found it confusing. Give you another example: bitmask(6,3) should return 0x (= ). bit 0,1,2 are all 0, bit 3,4,5,6 are all 1's. Function bang(x) returns!x without the use of the! operator. For example, bang(5) should return 0, and bang(0) should return 1. Hint: compare 5 and - 5, also compare 0 and - 0. See any pattern you can use? Function leastbitpos(x) returns a mask marking the least significant 1- bit of x. For example, the call leastbitpos(0x60) should return 0x (note that 0x60 = and that 0x20 = ). Hint: compare x and - x. try x=0b See any pattern? Function fitsbits(x,n) returns 1 if its leftmost parameter x can be represented as an n- bit two s complement integer. You may assume that the number of bits n satisfies 1 n 32. For example, fitsbits(5,3) = 0, since 5 cannot be represented in 3 bits (the largest 3- bit positive number is 3), and fitsbits(- 4,3) = 1, since - 4 can be represented in 3 bits as 100 (it s the 3- bit TMin). Hint: You don't really need to compare the biggest and smallest n- bit numbers. Any number that can be represented in n bits has some pattern if you use 32 bits to represent it. Function addok(x,y) returns 1 if the sum x+y can be computed without overflow; otherwise, it returns 0. Hint: Only the sign bits matter. Function isgreater(x,y) returns 1 if x > y, otherwise, it returns 0. Hint: you have to consider the case for overflow. Function multfiveeights(x) returns the product of x and 5/8, rounded toward 0, without causing overflow. For example, multfiveeights(77) = 48, and multfiveeights(- 22) = - 13.

10 Hint: You should be able to get it correct for x>=0. For x<0, if 8 does not divide x, you need to adjust the quotient. Better way is to adjust x before you take division when x<0. For some problems in this lab, you may also want to make sure to check x and x's negation - x. - x=~x+1 This ~x+1 may give you a lot of useful information in several problems. For example, bang(x), leastbitpos(x), float_i2f(x) - - please use round to even. See B&O book pp The default rounding mode of IEEE floating- point is to use round- to- even. In the following, I will round off the last 7 bits. Those examples will give you a good understanding about round- to- even. A , This number is closer to than so we will use B , This number is closer to than so we will use C , This number is equal distance from and In round- to- even, we will round it to an even number, that is to: D , This number is equal distance from and

11 In round- to- even, we will round it to an even number, that is to: Examples: /* * isasciidigit - return 1 if 0x30 <= x <= 0x39 (ASCII codes for characters '0' to '9') * Example: isasciidigit(0x35) = 1. * isasciidigit(0x3a) = 0. * isasciidigit(0x05) = 0. * Legal ops:! ~ & ^ + << >> * Max ops: 15 * Rating: 3 */ int isasciidigit(int x) { int bias1 = ~0x2F; int bias2 = 0x3a; int lower = x + bias1; int upper = ~x + bias2; return!((lower upper) >> 31); } - - /* * sign - return 1 if positive, 0 if zero, and -1 if negative * Examples: sign(130) = 1 * sign(-23) = -1 * sign(0) = 0 * Legal ops:! ~ & ^ + << >> * Max ops: 10 * Rating: 2 */ int sign(int x) We can easily replicate sign bit by doing: x>>31 = 0x0 if x>=0; x>>31 = 0xffffffff=-1 if x<0 We are close now. We need to get 0x1 if x>0. Think hard, we can do the following: int sign(int x) { return (x>>31) (!!x); }

12 /* * absval - absolute value of x * Example: absval(-1) = 1. * You may assume -TMax <= x <= TMax * Legal ops:! ~ & ^ + << >> * Max ops: 10 * Rating: 4 */ int absval(int x) The program should run as follows: if (x>=0) return x; else return -x; we know - x=~x+1; We need to come up with x if x>=0, ~x+1 if x<0. How do we do this? Well, let's make some observation. The only difference between a negative int and a non- negative int is the sign bit. We can replicate the sign bit by doing the following: x>>31 This gives us 0XFFFFFFFF if x<0 and 0X if x>=0. Then (x>>31) ^ x gives us x if x>=0, and ~x if x<0. We are close now. We only need to come up with a 1 for x<0. The following generates a 1 for x<0 (x>>31) & 0x1 gives us 1 if x<0 and 0 if x>=0. Then the program is like this: int absval(int x) { int mask=x>>31; return (mask ^ x) + (mask & 1); }