CS31 Lab 4: C Pointers and Assembly

Gain experience using pointers and dynamic memory allocation (malloc) in C.

Practice using gdb and valgrind to debug programs.

Practice converting C code with conditionals and loops to equivalent IA32 assembly code.

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

The get_values 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 3.

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 "TODO" comments removed (these are our 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 get_values 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 3 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 *values
void sort(float *values, int size);

You can similarly copy over your printArray function from your https://www.cs.swarthmore.edu/courses/CS31/S22//Labs/lab03 solution and use it to help you debug (note: you likely don’t want to do this with large files, but you can create some smaller input files on which to test with printing out array contents). Be sure to remove or comment out calls to printArray in your submitted program if you do this (this is just debugging output).

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 3 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 Ctrl-C to kill a running program stuck in an infinite loop.

The sum.s file contains the starting point IA32 code for the sum function that you will complete for Part 2. Your Part 2 solution should be implemented in this file.

prog.c: a main program for testing your sum implementation, You do not need to modify this program.

Your IA32 implementation of the sum function should be added to sum.s starting point file.

You do not need to edit prog.c, but looking at it in vim might help you understand how your sum function is being called.

Your solution must include a loop. It is well known that the sum of the first n positive integers is n*(n+1)/2, but you can not use that in your answer.

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.

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