Week 4 - Friday

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

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?"

 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

 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

 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

 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

#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; }

 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;

 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

 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

 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

 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

 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

 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

 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 0xc x x x Only for Linux kernel Memory for function calls Addresses for memory mapped files Dynamically allocated data Uninitialized globals Initialized globals Program code

 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

 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

 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

 Arrays

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