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 x86_64 bit assembly code.

It takes a single command line argument-- the input text file (floats, one per line), and computes and prints out a set of statistics about the data:

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 1.

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 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:         62
       min:     -1.801
       max:      3.317
      mean:      0.794
    median:      1.121
   std dev:      1.158
unused array capacity: 18

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.

We recommend that the code you submit has the "TODO" comments removed (if you want to you can keep the comment itself without the TODO in front if it helps you explain/layout your code.)

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

Write get_values without the re-allocation and copying steps first (data with <20 values).

Sort function: You can use your sort function from Lab 1 in this program! First, copy your sort function from Lab 1. Then, change the array parameter to a pointer to float. You can now use the same sort function for your 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);

For debugging, you can copy over your printArray function from your Lab 1 solution. Note: you likely don’t want to do this with large files. Be sure to remove and comment out calls to printArray in your submitted program if you do this.

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 1 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 x86_64 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 x86_64 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 x86_64 code to sum.s at a time, then compile and test it out by running prog, and add some more. Parts of that you test out do not even have to be parts of the solution, 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.