1. Week 4 - Friday

2.  What did we talk about last time?  Some extra systems programming stuff  Scope

5. Unix never says "please." Rob Pike Unix never says "please." Rob Pike  It also never says:  "Thank you"  "You're welcome"  "I'm sorry"  "Are you sure you want to do that?"

6.  What if you want to use a global variable declared in another file?  No problem, just put extern before the variable declaration in your file  There should only be one true declaration, but there can be many extern declarations referencing it  Function prototypes are implicitly extern int count; extern int count; file1.c file2.c file3.c program.c

7.  The static keyword causes confusion in Java because it means a couple of different (but related) things  In C, the static keyword is used differently, but also for two confusing things  Global static declarations  Local static declarations

8.  When the static modifier is applied to a global variable, that variable cannot be accessed in other files  A global static variable cannot be referred to as an extern in some other file  If multiple files use the same global variable, each variable must be static or an extern referring to a single real variable  Otherwise, the linker will complain that it's got variables with the same name

9.  You can also declare a static variable local to a function  These variables exist for the lifetime of the program, but are only visible inside the method  Some people use these for bizarre tricks in recursive functions  Try not to use them!  Like all global variables, they make code harder to reason about  They are not thread safe

10. #include void unexpected() { static int count = 0; count++; printf("Count: %d", count); } int main() { unexpected(); //Count: 1 unexpected(); //Count: 2 unexpected(); //Count: 3 return 0; } #include void unexpected() { static int count = 0; count++; printf("Count: %d", count); } int main() { unexpected(); //Count: 1 unexpected(); //Count: 2 unexpected(); //Count: 3 return 0; }

11.  You can also use the register keyword when declaring a local variable  It is a sign to the compiler that you think this variable will be used a lot and should be kept in a register  It's only a suggestion  You can not use the reference operator (which we haven't talked about yet) to retrieve the address of a register variable  Modern compilers are better at register allocation than humans usually are register int value;

12.  All real programs are written in multiple files  To compile such files, do the following  Create a header file (with a.h extension) for every file that contains prototypes for functions you're going to use in other files  #include those header files in every file that uses them  When you run gcc, put all the.c files needed on the line at the same time

13.  Your main() function and core program is in a file called program.c  You have files called networking.c and graphics.c that have networking and graphics functions that your program uses  You should have headers called networking.h and graphics.h (names don't have to match, but it is better if they do)  At the top of program.c should be:  To run gcc you type: #include "networking.h" #include "graphics.h" #include "networking.h" #include "graphics.h" gcc program.c networking.c graphics.c -o program

14.  You can compile a file into object code without linking it into an executable  Produces a.o file  That way, you can compile all the pieces separately and then link them later  This can be more efficient if you are updating some of the code but not all of it  To compile but not link, use gcc -c  We could compile the previous example as follows gcc –c program.c gcc –c networking.c gcc –c graphics.c gcc program.o networking.o graphics.o -o program gcc –c program.c gcc –c networking.c gcc –c graphics.c gcc program.o networking.o graphics.o -o program

15.  Now that we're talking about compiling multiple files, a makefile really makes (ha, ha) sense all: program program: program.o networking.o graphics.o gcc program.o networking.o graphics.o -o program program.o: program.c networking.h graphics.h gcc –c program.c networking.o: networking.c gcc –c networking.c graphics.o: graphics.c gcc –c graphics.c clean: rm -f *.o program all: program program: program.o networking.o graphics.o gcc program.o networking.o graphics.o -o program program.o: program.c networking.h graphics.h gcc –c program.c networking.o: networking.c gcc –c networking.c graphics.o: graphics.c gcc –c graphics.c clean: rm -f *.o program

17.  Recall that a process is a running program  Multiple copies of a single program can be running as different processes  A program is a binary file (generated by the compiler)  Formats used to be:  Assembly output (where the name a.out comes from)  COFF (Common Object File Format)  Now they are usually ELF (Executable and Linking Format)  Details about binary formats are more interesting when you're writing a compiler

18.  Every running process has a process ID (PID)  You can find out the PID of the currently executing code by calling the getpid() function  Every process also has a parent process (which has a parent PID)  Get that by calling getppid()  The parent is the process that created the current process  This parent-child relationship forms a tree all the way back to the first process init, which always has PID 1

19.  Layout for 32-bit architecture  Could only address 4GB  Modern layouts often have random offsets for stack, heap, and memory mapping for security reasons Text Data BSS Heap Memory Mapping Stack Kernel Space 1GB 3GB 0xc0000000 0x40000000 0x08048000 0x00000000 Only for Linux kernel Memory for function calls Addresses for memory mapped files Dynamically allocated data Uninitialized globals Initialized globals Program code

20.  Those addresses (from 0 to 4GB) are virtual addresses  Each program sees an address space stretching from 0 to 4GB  The OS transparently manages how those addresses are mapped to physical memory  The virtual address space is divided up into pages  Each page can be in memory or sitting on disk  Pages are typically moved into memory only when needed

21.  It isolates processes from each other  Since they have different address spaces, it is harder for one program to read the data out of another  Processes can share the same memory without inadvertently trampling on each other  Since paging is controlled by the OS, pages can be marked read-only  Programmers don't need to worry about the actual layout of memory  Programs can load faster because only part of them needs to be put into RAM

22.  ps gives a snapshot of the current processes running  top gives repeatedly updated information about the processes running  The kill command lets you end a process  You have to have sufficiently high privileges to do so

25.  Arrays

26.  Read K&R chapter 5  Keep working on Project 2