Spring 2007 May 16, 2007 CS107 Midterm Solution

Transcription

1 CS107 Handout 26S Spring 2007 May 16, 2007 CS107 Midterm Solution Problem 1: Color Theory (15 points: ) Consider the following struct definitions: typedef struct palette short *lavender; char indigo[4]; struct palette *peach[2]; palette; line 1 line 2 line 3 static palette **swatch(palette *ecru, int mint); static int colorwheel(palette ruby, int seafoam) seafoam = ruby.lavender[ruby.indigo[3]]; ruby.peach[0] += ((palette *)ruby.indigo)->lavender[2]; return swatch(&ruby, 8) - ruby.peach; Generate code for the entire colorwheel function. Be clear about what assembly code corresponds to what line. You have this and the next two pages for your work. seafoam // line 1 R1 = M[SP + 4]; // load ruby.lavender R2 =.1 M[SP + 11]; // load ruby.indigo[3] ruby.peach[1] ruby.peach[0] R3 = 2 * R2; // scale by sizeof(short) ruby.indigo[0...3] R4 = R1 + R3; // full address of rhs short R5 =.2 M[R4]; // pull in rhs short ruby.lavender M[SP + 20] = R5; // write rhs val to seafoam saved PC // line 2 SP R1 = M[SP + 12]; // load old lhs R2 = M[SP + 8]; // load lavender of pretend struct starting at &ruby.indigo[0] R3 =.2 M[R2 + 4]; // load third short in short array starting at R2 R4 = R3 * 16; // scale offset in R3 by sizeof(palette) R5 = R1 + R4; // compute new value for lhs M[SP + 12] = R5; // flush to lhs space // line 3 R1 = SP + 4; // compute &ruby SP = SP 8; // make space to two parameters M[SP] = R1; // press ecru M[SP +4] = 8; // press mint CALL <swatch> // jump away, expecting RV to be populated by a palette ** SP = SP + 8; // deallocate params R2 = SP + 12; // load &ruby.peach[0] R3 = RV R2; // compute difference in raw bytes RV = R3 / 4; // divide by sizeof(palette *) and populate RV RET;

2 2 Criteria for Problem 1 (written for the staff, visible to the students for transparency) Criteria for Line 1: 5 points Properly pulling the lavender field: 1 point Properly pulling the third character in indigo: 1 point Properly scaling the offset and computing the location of the relevant short: 1 point Properly loading the short: 1 point Properly writing the four byte version of that short to seafoam: 1 point 0.5 point deductions are fine, and we double ding for the same error, but we don t triple ding, so make sure between all three lines you cap similar deductions re.1/.2, and illegal assembly code instructions at 1 point total. Line 2 is 5 points Properly grabbing lavender field of pretend struct using the proper number of dereferences: 2 points (this is 2 or 0, because it s difficult to get this right, and it s clear from the sample midterm and all the examples that this is challenging.) Properly grabbing third short: 1 point Properly scaling it by sizeof(palette): 1 point Properly identifying, loading, and eventually updating the correct lhs l-value: 1 point Line 3 is 5 points Allocating and deallocating the right amount of space for the params: 1 point Populates param space within correct values, in correct order: 1 point Properly computes the raw number of bytes sitting in between return value and &ruby.peach[0]: 1 point Scales back by sizeof(palette *): 1 point Populates RV before returning: 1 point

3 3 Problem 2: packpackets (15 points) You re to write code that traverses a linked list of custom nodes and builds a dynamically allocated array of bytes large enough to store the meaningful data held by the linked list. Each node stores one or more packets of raw information, where each packet is preceded by a two-byte short stating the length (in bytes) of the packet that follows it. The end of the packet sequence is marked by a two-byte zero, and the four bytes after that store the address of the next node in the list (or NULL, if the node is the last in the list). The following node contains three packets of length 20, 10, and 30 bytes, in that order. The number of bytes making up the entire node is You re to write a function called packpackets that, given the address of the first node in such a list, builds a dynamically allocated byte array where all packets in the linked list are replicated verbatim, one after another, in the same order they appear in the list. So, given the following list: NULL your packpackets function would return the address of the first byte of this dynamically allocated figure: Here are some constraints I m imposing on your implementation. The address passed to packpackets is the address of the first short storing the number of bytes making up the first packet in the first node. Each node alternates between shorts and packets. A two-byte zero marks the end of the packet sequence in any given node. Every node ends with a four-byte pointer identifying the location of the next node in the list. You should implement this function iteratively, and your algorithm should accomplish everything in exactly one traversal. This requires you to call realloc for each packet you encounter during your one traversal. [Tip: When NULL is passed as the first argument to realloc, realloc just calls malloc on your behalf.] This artificial constraint is being imposed so that I can test your understanding of realloc. For simplicity, you may assume the list contains at least one node, and that each node contains at least one packet. You needn t worry about any alignment restrictions at all. You shouldn t free or modify the original list in any way. Use the next page for your implementation. Feel free to tear this page out.

4 4 Problem 2 Continued /** * Function: packpackets * * Builds a contiguous array version of the packet list structure according * to the explanations provided on the prior page. The parameter passed * is of type short *, because the first meaningful piece of information * stored in the list is a two-byte short. The return value is of type * void *, because the implementation has no type information about the * packet data. */ void *packpackets(short *list) void *image = NULL; int imagesize = 0; while (list!= NULL) int packetsize = *list++; char *data = list; if (packetsize > 0) image = realloc(image, imagesize + packetsize); memcpy((char *) image + imagesize, data, packetsize); imagesize += packetsize; list = (short *)(data + packetsize); else list = *(short **)data; // list = *(void **)data would work too return image; Criteria for Problem 2: 15 points Successfully creates the initial segment, either as NULL of 0 bytes before any packets are processed, or via a standalone malloc call that s special-cased up front: 2 points Correctly pulls the size of the next packet: 1 point Correctly identifies the location of the data image: 1 point Correctly calls realloc to resize the block to make room for the new packet: 3 points o o o Passes in the correct size in bytes as the second argument: 1 point Catches the return value (assert not required): 1 point Understands that realloc frees the old block and memcpy s the material so the client doesn t have to: 1 point Keeps track of the current image length: 1 point Properly advanced to the next packet size in the node: 2 points o 1 point for correct pointer arithmetic with necessary casting (note that my data is a char *, o while there s might be a void *, thereby requiring a cast.) 1 point for any additional casts required of the variable assignment. Properly detects end-on-node condition: 1 point Properly casts and dereferences to advance to the next node: 1 point Handles NULL: 1 point Returns image: 1 point Points dedicated to other issues we can t anticipate: 1 point (point mat be used to deduct for spurious ampersanding, for instance)

5 5 Problem 3: Python (15 points) Python provides support for objects just like C++ and Java do, but its implementation model is different. Rather than requiring that all fields be stated at compile time, Python allows its objects to take on new fields as the code executes. Here s how a Python object might grow to represent a Stanford student: student = # initialized to be an empty object student['name'] = 'Edward Requenez' student['numunits'] = 15 student['gpa'] = student['friends'] = ['Bill','Will','Sawyer','Alex','Daniel'] student['hometown'] = # initialized to be an empty object student['hometown']['city'] = 'Dallas' student['hometown']['state'] = 'Texas' student['hometown']['zip'] = You don t need to know Python to know what the code s trying to do. The coder decided to model some Stanford student as a Python object with five properties. Each accommodates a value of a different data type. Python doesn t require that object structure be stated up front. We re going to assume that all Python values whether they re top-level primitives or fields within an aggregate record, are implemented in terms of the following pure C enum and struct definitions: typedef enum Integer, Float, String, Array, Object PythonType; typedef struct const char *id; PythonType type; char value[4]; PythonPair; Don t be misled PythonPair's third field. It looks like it stores a small number of characters, but it actually sits there as a general-purpose four-byte register of sorts. We ve done enough C casting and reinterpretation of bit patterns to know how to exploit that little value array for all it s worth. Sometimes we used those four bytes to store an integer, as with: numdalmations = 101 For other primitives, we use the four bytes to store something else: pi = ; contestant = 'Sanjaya Malakar' The value array contains the bit pattern of either a four-byte integer, a four-byte float or a four-byte pointer to a null-terminated char array. We rely on the type field to figure out what those four bytes are storing Sanjaya Malakar\0 Integer Float String numdalmations\0 pi\0 contestant\0

6 And guess what? Python objects and arrays are backed by the infamous hashset and vector types from Assignments 3 and 4. 6 When a field is an array, the value array stores the address of a vector of PythonPairs, where the id fields just store NULL as a sentinel that neither the id fields nor the colons need to be printed. When a field is an inner object, value stores the address of a hashset. The hashset is the in-memory representation of a Python object that s been built up to include an arbitrarily large number of properties. Those properties are stored as PythonPairs in a hashset, and provided you allow for some of those PythonPairss to store vector *s and hashset *s, you have the means to recursively build Python objects with primitives, Python arrays, and Python objects as fields. Given the address of a hashset of PythonPairss, you re going to write a function called serializeobject that synthesizes the C string representation of the entire object, just like Python would. Primitives are serialized as you d expect, though all strings constants are delimited by single quotes. Arrays are square-bracket-delimited, comma-separated lists. The student object from above looks like this: 'name':'ed Requenez','numUnits':15,'gpa':3.966, 'friends':['bill','will','sawyer','alex','daniel',], 'hometown':'city':'dallas','state':'texas','zipcode':75209,, A full object s serialization is delimited by curly braces. Between those curly braces is a comma-separated list of id/value pairs. The identifiers are always strings with singe quotes. Each value gets published either as the primitive it is, or recursively as the array or sub-object it s addressing. The identifiers are separated from their values by colons, there s no intervening white space, and it s fine to have a trailing comma after the last entry within an array of object serialization. This is a difficult question that necessarily uses HashSetMap. And because HashSetMapFunction and VectorMapFunction have the same prototype, it makes sense use VectorMap to serialize Python arrays. You may assume the existence of convenience functions called intcpy and floatcpy, which operate much like strcpy, in that they place '\0'-terminated C strings in the specified buffer. In this case the strings they place are the textual equivalents of integers and floats. void intcpy(char *dest, int value); // does not allocate memory void floatcpy(char *dest, float value); // does not allocate memory Use the space provided on the next three pages for your implementation. You re more than encouraged to decompose your solution. Don t orphan any memory. For simplicity, you may assume that the full serialization is less than 8192 characters (a nice power of 2), but the dynamically allocated string that s ultimately returned must use only as much memory as is absolutely necessary to store the serialization.

7 7 Problem 3 Continued /** * Function: serializeobject * * Traverses the hashset representation of a Python object and * synthesizes a single, dynamically allocated C string storing the * textual representation of the entire object. */ char *serializeobject(hashset *object) char text[8192] = '\0'; // 'master' buffer that's threaded through traversal appendobject(text, object); return strdup(text); // take persistent snapshot of accumuation void appendstring(char *text, const char *str) strcat(text, "'"); strcat(text, str); strcat(text, "'"); // post condition: text has been extended by "'" + string + "'" void appendarray(char *text, vector *array) strcat(text, "["); VectorMap(array, appendpair, text); strcat(text, "]"); // post condition: text has been extended by "[" + array + "]" void appendobject(char *text, hashset *object) strcat(text, ""); HashSetMap(array, appendpair, text); strcat(text, ""); // post condition: text has been extended by "" + object + "" void appendpair(void *elemaddr, void *auxdata) char *text = auxdata; // rediscover 'master' buffer PythonPair *pair = elemaddr; if (pair->id!= NULL) appendstring(text, pair->id); strcat(text, ":"); switch (pair->type) case Integer: intcat(text, *(int *) pair->value); break; case Float: floatcat(text, *(float *) pair->value); break; case String: appendstring(text, *(char **) pair->value); break; case Array: appendarray(text, *(vector **) pair->value); break; case Object: appendobject(text, *(hashset **) pair->value); break; strcat(text, ","); void intcat(char *text, int i) intcpy(text + strlen(text), i); void floatcat(char *text, float f) floatcpy(text + strlen(text), f);

8 8 TA Notes Most students don t know about strcat, but they certainly should know strcpy. It s perfectly acceptable to me if that write code that computes the strlen every single time so it knows where in the text buffer it should continue strcpying. Some students threaded a struct through the code tree, where the struct contains the base address of the character buffer and the number of characters that have been written to it. That way they know where to continue writing characters. Several students didn t think to switch on the enumerated type, presumably because they didn t know it s backed by a scalar type. If you see cascaded if/else of tests like pair->type == String, that s fine, but note that a switch statement would make things a little cleaner. Don t worry about replication of code (they were feeling time pressure), and remark but don t penalize for missing commas and colons, since it s not exactly the focus of the problem, it easy to overlook, and once everything else worked it would be easy to debug it. Problem 3 Criteria: 15 points Proper string management is worth 7 points Sets aside the character buffer of the recommended size: 2 points (take off 1 if they dynamically allocate it and ultimately orphan it) Returning a string that s dynamically allocated, null-terminated, and is only as big as it needs to be to store the serialization: 2 points (take off 1 if they dynamically allocated the figure of size 8192 and returned that figure) Understands how to append text to the end of the running serialization (requires strcat, or combination of strcpy and strlen): 1 point Figures out how to append ints and floats, either using my intcpy and floatcpy inventions, or by using sprintf: 1point Mechanics of HashSetMap and VectorMap is worth 3 points Correctly threads buffer (or buffer/int pair) through as clientdata: 1 point Gets the prototype correct (void */void *) and properly reinterprets these void *s to be the data types they really are: 2 points (they lose both points if the prototypes are incorrect, and the lost just one point if they match the prototype but cast things incorrectly) Reinterpretations of the value fields are worth 3 points Properly casts value (=== &value[0]) when the value array is storing number data: 1 point Properly casts value to be a char ** and then dereferences it when the value array is storing a char *: 1 point Correctly casts value to be a container ** and then dereferences it: 1 point There are some dirtier ways to manage all this (like declaring a local variable of the required type and memcpy ing the material into it). As long as it works, I m fine with it. Slack points are capped at 2 points Use these two points to deduct for incorrect ampersanding (cap at 1 point), dotting instead of arrowing (cap at just 1 point), forgetting to print the id field, and so forth. Cap deductions here at 2 points.