CS31 Lab 4: C Pointers and Dynamic Memory Allocation, IA32 Code Writing

Implement your solution in stats.c, which includes some starting point code.

The getvalues function: takes the name of a file containing input values, reads in values from the file into a dynamically allocated array, and returns the dynamically allocated array to the caller. The array’s size and capacity are "returned" to the caller through pass-by-pointer parameters:

float *get_values(int *size, int *capacity, char *filename);

After reading in the values from the file, your program should sort the array (and note that your program should be able to easily compute min, max and median on a sorted array of values). See the Tips section about how to re-use your sort function from the Lab 2.

For full credit, your program must be free of valgrind errors. Do not forget to close the file you opened! If you don’t, valgrind will likely report a memory leak.

Your code should be commented, modular, robust, and use meaningful variable and function names. This includes having a top-level comment describing your program and listing your and your partner’s names and the date. In addition, every function should include a brief description of its behavior. You may not use any global variables for this assignment.

It should be evident that you applied top-down design when constructing your submission (e.g., there are multiple functions, each with a specific, documented role). You should have at least 4 function-worthy functions.

You should not assume that we will test your code with the sample input files that have been provided.

When run, your program’s output should look like the output shown below from a run of a working program. To make my job of grading easier, please make your output match the example as closely as possible.

$ ./stats large.txt
Results:
-------
num values:         94
       min:      0.333
       max:      3.000
      mean:      1.161
    median:      1.000
   std dev:      0.788
unused array capacity: 66

For increased precision, use the C double type to store and compute the mean and the square root.

Your code should be commented, modular, robust, and use meaningful variable and function names. Each function should include a brief description of its behavior. Look at the C code style guide for examples of complete comments, tips on how not to wrap lines, good indenting styles and suggestions for meaningful variable and function names in your program.

Code you submit should have my "TODO" comments removed (these are my notes to you, as you implement them remove the "TODO").

Before even starting to write code, use top-down design to break your program into manageable functionality.

Try getting getvalues to work without the re-allocation and copying part first (for fewer than 20 values). Once that works, then go back and get it to work for larger numbers of input values that require mallocing up new heap space, copying the old values to the new larger space, and freeing up the old space.

Sort function: You can use your sort function from Lab 2 in this program. To do so, just copy your sort function from the previous lab’s .c file into this file, and then change the array parameter to a pointer to float. And that is it — you can use the same sort function to sort the dynamically allocated array!

// change the prototype and function definition of your sorting function
// so that its first parameter is float *array
void sort(float *values, int size);

The C math library has a function to compute square root: double sqrt(double val);. You can pass sqrt a float value and C will automatically convert the float value to a double.

See the Lab 2 lab assignment for documentation about using the readfile library (and also look at the readfile.h comments for how to use its functions).

Take a look at the textbook, weekly lab code and in-class exercises to remind yourself about malloc, free, pointer variables, dereferencing pointer variables, dynamically allocated arrays, and passing pointers to functions.

Use CNTRL-C to kill a running program stuck in an infinite loop.

Write C-goto versions of sum function, the if and for loop parts in particular, to help you with the translations of those parts.

Try adding a little bit of IA32 code to sum.s at a time, then compile and test it out by running prog, and add some more. Parts that you test out do not even have to be parts of the solution, but testing if you can perform some of the steps like returning some value, and initializing a local variable. For example:

If you have errors, trace through the instruction’s on paper drawing memory contents and register contents as you go.

You can also try using gdb (or ddd) to debug your program at the assembly level. Set a breakpoint in sum and use ni to step through instruction execution. print to (ex. print $eax) to print out register values.