15-213 RECITATION Cache Lab and C Aishwarya Prem Renu 16 Feb 2015

Agenda Buffer lab – Due TOMORROW! Cache lab – Out TOMORROW! Due 26th Feb C Assessment Using the C Standard Library Compilation (gcc and make) Debugging Tips (Yes, you can still use GDB. ) Version Control Style Demo

C Assessment Cache Lab = First ‘Programming in C’ Lab Steps to see if you’re ready: Can you solve all of these upcoming C-exercises effortlessly? These problems test fundamental C-concepts. If not, please come to the C-bootcamp DATE, TIME, LOCATION: TBA You need this for the rest of the course. So, if in doubt, COME TO THE BOOTCAMP, and get all your doubts cleared!

Important C Topics Types: Pointers/Structs Memory Management: Malloc/Free, Valgrind Common library functions: string.h, stdlib.h, stdio.h Grab-bag: macros, typedefs, function-pointers, header-guards

Exercise #1 Spot the errors! int main() { int* a = malloc(100*sizeof(int)); for (int i=0; i<100; i++) if (a[i] == 0) a[i]=i; else a[i]=0; } free(a); return 0;

Exercise #1 Malloc does not initialize memory! So you get junk data, and the behavior of main is undefined. int main() { int* a = malloc(100*sizeof(int)); /* Q.3 Is anything missing here? */ for (int i=0; i<100; i++) if (a[i] == 0) a[i]=i; else a[i]=0; } int b = sizeof(a); int c = (a == &a[0]); free(a); return 0; Q.1 What can you use instead of malloc, so you can be sure of the contents? Q.2 What are the values of b and c? Q.4 What does free(a) do?

Exercise #1 Malloc may return NULL! int main() { int* a = malloc(100*sizeof(int)); if(a == NULL) { callerror(); //Define your own function return; } for (int i=0; i<100; i++) if (a[i] == 0) a[i]=i; else a[i]=0; free(a); int b = sizeof(a); // b = 8 (for 64-bit systems) int c = (a == &a[0]); // c = 1 return 0; Malloc may return NULL! In that case, you would get a dreaded Segmentation fault when you try to dereference. And Nope, you do not want that happening.

Exercise #2 Q.1 What are the values of c and d? #define SUM(a,b) a+b int sum(int a, int b) { return a+b; } int main { int c = SUM(2,3)*4; int d = sum(2,3)*4; return 1; Q.1 What are the values of c and d?

Exercise #3 Safe or not? int * funfun(int * allocate) { allocate = malloc(sizeof(int)); int a = 3; return &a; } int main int * ptr1; int * ptr2 = funfun(ptr1); printf(“%p %p”, ptr1, ptr2); return 1;

Exercise #3 Safe or not? int * funfun(int * allocate) { allocate = malloc(sizeof(int)); int a = 3; return &a; } int main int * ptr1; int * ptr2 = funfun(ptr1); printf(“%p %p”, ptr1, ptr2); return 1; Function returning address of local variable! Not allowed that was allocated on the stack and is not safe to access after you return from funfun! Note: Printing pointer values

Exercise #4 Spot the errors! struct node { int a; struct node* next; }; typedef struct node * nodeptr; int main() nodeptr ** data = (nodeptr **)malloc(4*sizeof(nodeptr *)); for( int i = 0; i<4; i++) data[i] = (nodeptr *)malloc(3*sizeof(nodeptr)); } for( int j = 0; j<3; j++) data[0][j]->a = 213; } }

Exercise #4 Segmentation Fault. Q. Now, are all accesses safe? struct node { int a; struct node* next; }; typedef struct node * nodeptr; int main() nodeptr ** data = (nodeptr **)malloc(4*sizeof(nodeptr *)); for( int i = 0; i<4; i++) data[i] = (nodeptr *)malloc(3*sizeof(nodeptr)); } for( int j = 0; j<3; j++) data[0][j] = malloc(sizeof(struct node)); data[0][j]->a = 213; } /* Free everything you malloc! */ } data[i] has been allocated to be of type nodeptr *, However, each of these nodeptr in the heap do not point to anything yet, and are uninitialized! Hence, when you dereference data[0][j], you get a Segmentation Fault. Q. Now, are all accesses safe?

Exercise #4 Segmentation Fault. data[i] has been allocated to be of type nodeptr *, However, each of these nodeptr in the heap do not point to anything yet, and are uninitialized! Hence, when you dereference data[0][j], you get a Segmentation Fault. struct node { int a; struct node* next; }; typedef struct node * nodeptr; int main() nodeptr ** data = (nodeptr **)malloc(4*sizeof(nodeptr *)); for( int i = 0; i<4; i++) data[i] = (nodeptr *)malloc(3*sizeof(nodeptr)); } for( int j = 0; j<3; j++) data[0][j] = malloc(sizeof(struct node)); data[0][j]->a = 213; } /* Free everything you malloc! */ } NO! Check if what malloc returned is non-NULL before you dereference!

Use the C Standard Library Please Use it! Don’t write code that’s already been written! Your work might have a bug or lack features You spend time writing code that may be inefficient compared to an existing solution. All C Standard Library functions are documented. Some of the commonly used ones are: stdlib.h: malloc, calloc, free, exit, atoi, abs, etc string.h: strlen, strcpy, strcmp, strstr, memcpy, memset, etc stdio.h: printf, scanf, sscanf, etc Use the UNIX man command to look up usage / online references.

Example: getopt int main(int argc, char** argv) { int opt, x; /* looping over arguments */ while(-1 != (opt = getopt(argc, argv, “x:"))) switch(opt) case 'x': x = atoi(optarg); break; default: printf(“wrong argument\n"); } getopt is used to break up (parse) options in command lines for easy parsing by shell procedures, and to check for legal options. (From the man pages! See, it’s really helpful!) Use it to parse command line arguments and don’t write your own parser! Colon in “x:” indicates that it is a required argument optarg is set to value of option argument Returns -1 when no more args are present Useful for Cache lab!

Write Robust Code We are writing code for the real world: errors will happen! System calls may fail User may enter invalid arguments Connections may die --- Experience with this in Proxylab! … but your code should NOT crash! Handle errors gracefully Indicate when errors happen They may be recoverable, you may have to terminate Remember to free any resources in use Else, suffer the wrath of a thousand unicorns … and our sadistic style-grading.

Solution 1 : Use CS:APP Wrappers http://csapp.cs.cmu.edu/public/1e/ics/code/src/csapp.c It Has wrapper methods for all core system calls Explicitly checks for return values and then calls unix_error if something went wrong void *Malloc(size_t size) { void *p; if ((p = malloc(size)) == NULL) unix_error("Malloc error"); return p; } Copy/paste required wrappers in source code, since we will accept only single files in earlier labs. Definitely include this file in your proxy lab submission!

Solution 2: Write your own checks Example: file IO functions fopen: open a given file in a given mode (read/write/etc) fclose: close file associated with given stream fscanf: read data from the stream, store according to parameter format May be useful for Cache lab! Error-codes: fopen: return NULL fclose: EOF indicated fscanf: return fewer matched arguments, set error indicator FILE *pfile; // file pointer if (!(pfile = fopen(“myfile.txt”, “r”))) { printf(“Could not find file. Opening default!”); pfile = fopen(“default.txt”, “r”); }

Compilation: Using gcc Used to compile C/C++ projects: List the files that will be compiled to form an executable Specify options via flags Use man gcc for more details Important Flags: -g: produce debug information (important; used by gdb/gdbtui/valgrind) -Werror: treat all warnings as errors (this is our default) -Wall/-Wextra: enable all construction warnings -pedantic: indicate all mandatory diagnostics listed in C-standard -O1/-O2: optimization levels -o <filename>: name output binary file ‘filename’ Example: gcc -g -Werror -Wall -Wextra -pedantic foo.c bar.c -o baz

Compilation: make Easy way to automate bug shell command with lots of flags and files Makefiles allow you to use a single operation to compile different files together Efficient, because it only recompiles updated files Lab handouts come with a Makefile: Don’t change them make reads Makefile and compiles your project See http://www.andrew.cmu.edu/course/15-123- kesden/index/lecture_index.html for more details on how to ‘make’a Makefile

Debugging: gdbtui Allows you to see source Compile with –g debug flag Example: gcc –g –m32 myprog.c –o myprog Run using gdbtui myprog layout src/asm/regs/split – To display the source / assembly / registers / source & assembly layout focus src/asm/regs Make the source / assembly / registers window active for scrolling

Debugging: valgrind Use it to Find and eliminate memory errors, detect memory leaks Common errors you can fix: Illegal read/write errors Use of uninitialized values Illegal frees Double frees Overlapping source/destination addresses Use gcc with –g to get line number of leaks Use valgrind --leak-check=full for thoroughness

Debugging: Small tip #ifdef DEBUG # define dbg_printf(...) printf(__VA_ARGS__) #else # define dbg_printf(...) #endif Use this to easily wither print or not print without having to comment out print statements each time!

Version Control You should use it. Now. Avoid suffering during large labs (malloc, proxy) Basic ideas: Complete record of everything that happened in your code repository Ability to create branches to test new components of code Ease in sharing code with others Well, outside of 213 of course…

Version Control Basics git init: Create a new repository Indicated by .git file git status: Show working tree-status Untracked files, staged files git add <file_name> Stage a file to be committed (does not perform the commit) git add . stages all files in current directory git commit Make a commit from all the stage files git commit -m “Commit message” Warning Be cautious when rewinding commits!!! Follow online usage instructions carefully! Use Stack Overflow, http://try.github.io, man pages

Style http://cs.cmu.edu/~213/codeStyle.html Good documentation Header comments, large blocks, tricky bits Check error/failure conditions Must program robustly 80 chars per line: Use grep '.\{80,\}' filename to find lines more than 80 chars No memory or file descriptor leaks Use interfaces for data structures (Don’t repeat code) Modularity of code No magic numbers Use #define Consistency and whitespace http://cs.cmu.edu/~213/codeStyle.html

Notes Go to the C Boot Camp if you have any doubts! C Boot Camp: Time: TBD Date: TBD Location: TBD We are style grading from Cache lab onwards!

Demo

Acknowledgements Derived from recitation slides by Arjun Hans, Jack Biggs ftp://ftp.gnu.org/old-gnu/Manuals/gdb/html_chapter/gdb_19.html http://csapp.cs.cmu.edu/ xkcd