To CS-034 be or not to be (efficient)
T. Shakespeare Doeppner P. Hugo Van Hentenryck
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
1
C/C++ versus Java
Where does the time go?
arrays arrays virtual methods virtual stack machine: JVM stack garbage collection Concepts garbage compiler optimizations compiler x86 architecture x86 Handles Handles
3/16/2005 CS-034: Lecture 7 (twd/pvh: 2005) 2
x86 architecture: registers
Control Registers
%ebp (frame ptr), %esp (stack ptr), %eis (pc)
S-Registers (must be saved by subroutines)
%ebx, %esi
T-Registers (must not be saved by subroutines)
%eax, %ecx, %edx
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
3
x86: the C Stack
increasing argument n . argument 1 return address %ebp previous %ebp saved registers local variables %esp
3/16/2005
Callers frame
Current frame
arguments
CS-034: Lecture 7 (twd/pvh: 2005) 4
x86 assembly language
movel move from register/memory to register/memory move pushl/popl push and pop from the stack push addl, subl, multl, xorl, andl arithmetic expression arithmetic leal load immediate (load effective address) load jmp jump jump
3/16/2005 CS-034: Lecture 7 (twd/pvh: 2005) 5
x86 assembly language
Conditional jumps
two steps two first compare and set flags first then jump based on the flags then
Function calls
call: pushes %esi on the stack and jump to call: subroutine ret: pops the address on the stack and jump there ret: leave: restore %ebp and %esp leave:
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
6
Compiler Optimizations
Register allocation Register Inlining Inlining Deadcode elimination Deadcode Subexpression factorization Subexpression peephole optimization peephole
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
7
Compiler Optimizations
Register allocation
compilers try to allocate local variables in registers compilers very useful for expressions very
Not always possible
no enough registers no arrays and structures arrays & may take the address of a local variable may
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
8
Compiler Optimizations
Inlining
compilers try to remove function calls compilers replace them with the body replace
Not always possible
recursion recursion size of the code size
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
9
C 2 x86
int sum(int a,int b) int sum(int a,int b) {{ return a + b; sum: return a + b; sum: pushl }} pushl movl movl movl movl movl movl popl popl addl addl ret ret %ebp push ebp %ebp push ebp %esp, %ebp ebp <- esp %esp, %ebp ebp <- esp 12(%ebp), %eax eax <- b; 12(%ebp), %eax eax <- b; 8(%ebp), %edx 8(%ebp), %edx edx <- a; edx <- a; %ebp ebp <- pop %ebp ebp <- pop %edx, %eax eax <- eax+edx %edx, %eax eax <- eax+edx return return
Register allocation: where is the return address?
3/16/2005 CS-034: Lecture 7 (twd/pvh: 2005) 10
How to get assembly code?
/Users/pvh/courses/cs034 [48] -> gcc -O2 -S fact.c /Users/pvh/courses/cs034 [48] -> gcc -O2 -S fact.c /Users/pvh/courses/cs034 [49] -> ls -l /Users/pvh/courses/cs034 [49] -> ls -l -rw-r----- 1 pvh fac 516 Mar 12 12:45 fact.s -rw-r----- 1 pvh fac 516 Mar 12 12:45 fact.s /Users/pvh/courses/cs034 [50] -> gcj -O2 -S Fact.java /Users/pvh/courses/cs034 [50] -> gcj -O2 -S Fact.java -rw-r----- 1 pvh fac 516 Mar 12 12:45 Fact.s -rw-r----- 1 pvh fac 516 Mar 12 12:45 Fact.s Native compiler for java
3/16/2005 CS-034: Lecture 7 (twd/pvh: 2005) 11
int sum(int a,int b) int sum(int a,int b) {{ int ss= 0; int = 0; ss= a + b; = a + b; ss+= a + s; sum: += a + s; sum: pushl %ebp return s; pushl %ebp return s; movl %esp, %ebp }} movl %esp, %ebp movl 8(%ebp), %edx movl 8(%ebp), %edx movl 12(%ebp), %ecx movl 12(%ebp), %ecx popl %ebp popl %ebp movl %edx, %eax movl %edx, %eax addl %ecx, %eax addl %ecx, %eax leal (%edx,%eax,2), %eax leal (%edx,%eax,2), %eax ret ret
C 2 x86
3/16/2005
Register allocation: where is Register s?
CS-034: Lecture 7 (twd/pvh: 2005)
push ebp push ebp bp <- esp bp <- esp edx <- a; edx <- a; ecx <- b; ecx <- b; ebp <- pop ebp <- pop eax <- edx eax <- edx eax <- eax+ecx eax <- eax+ecx eax <- edx+2* eax eax <- edx+2* eax return return
12
C 2 x86
int sum(int a,int b) int sum(int a,int b) {{ int ss= 0; int = 0; ss= a + b; = a + b; ss+= a + s; += a + s; }} sum: sum: pushl pushl movl movl popl popl ret ret
%ebp %ebp %esp, %ebp %esp, %ebp %ebp %ebp
Deadcode elimination Deadcode
3/16/2005 CS-034: Lecture 7 (twd/pvh: 2005) 13
sum: sum: pushl %ebp pushl %ebp movl %esp, %ebp movl %esp, %ebp subl $4, %esp subl $4, %esp int sum(int a,int b) int sum(int a,int movl 16(%ebp), %eax b) movl 16(%ebp), %eax {{ addl 12(%ebp), %eax addl 12(%ebp), %eax int ss= 0; int = 0; movl %eax, -4(%ebp) movl %eax, -4(%ebp) ss= a + b; = a + b; movl -4(%ebp), %edx movl -4(%ebp), %edx ss+= a + s; += a + s; movl -4(%ebp), %eax movl -4(%ebp), %eax return s; return s; addl 12(%ebp), %eax addl 12(%ebp), %eax }} leal (%eax,%edx), %eax leal (%eax,%edx), %eax movl %eax, -4(%ebp) movl %eax, -4(%ebp) movl -4(%ebp), %eax movl -4(%ebp), %eax leave leave ret ret
Java 2 x86
push ebp push ebp ebp <- esp ebp <- esp esp <- esp --4; esp <- esp 4; eax <- b eax <- b eax <- eax + a eax <- eax + a ss<- eax <- eax edx <- ss edx <eax <- ss eax <eax <- eax + a eax <- eax + a eax <- eax + edx eax <- eax + edx res <- eax res <- eax eax <- ss eax <restore esp & ebp restore esp & ebp return return
14
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
Arrays
Big differences between C/C++ and Java
C arrays are just pointers Java arrays
objects objects bound checking bound
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
15
C 2 x86
int sum(int* a) {{ int sum(int* a) int ss= 0; int = 0; int i; int i; for(i = 0; ii< 10; ++i) for(i = 0; < 10; ++i) ss+= a[i]; += a[i]; return s; return s; }}
ssum: um: pushl pushl xorl xorl movl movl movl movl xorl xorl .L6: .L6: addl addl incl incl cmpl cmpl jle jle popl popl ret ret
%ebp push ebp %ebp push ebp %eax, %eax eax <- 0 %eax, %eax eax <- 0 %esp, %ebp ebp <- esp %esp, %ebp ebp <- esp 8(%ebp), %ecx ecx <- a 8(%ebp), %ecx ecx <- a %edx, %edx edx <- 0 %edx, %edx edx <- 0 (%ecx,%edx,4), %eax (%ecx,%edx,4), %eax eax <- eax + M[ecx + 4 * edx] eax <- eax + M[ecx + 4 * edx] %edx edx <- edx+1 %edx edx <- edx+1 $9, %edx $9, %edx .L6 jmp if edx <= 9 .L6 jmp if edx <= 9 %ebp ebp <- pop %ebp ebp <- pop
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
16
Arrays in C
Observe no space on the stack i is register %edx s is register %eax (return value)
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
17
Java 2 x86
int sum(int[] a) {{ int sum(int[] a) int ss= 0; int = 0; int ii= 0; int = 0; for(i = 0; ii< 10; ++i) for(i = 0; < 10; ++i) ss+= a[i]; += a[i]; return s; return s; }}
pushl %ebp pushl %ebp movl %esp, %ebp movl %esp, %ebp subl $24, %esp subl $24, %esp movl $0, -4(%ebp) movl $0, -4(%ebp) movl $0, -8(%ebp) movl $0, -8(%ebp) .L2: .L2: cmpl $9, -8(%ebp) cmpl $9, -8(%ebp) jle .L4 jle .L4 jmp .L7 jmp .L7 .L4: .L4: movl -4(%ebp), %eax movl -4(%ebp), %eax movl %eax, -12(%ebp) movl %eax, -12(%ebp) movl 12(%ebp), %edx movl 12(%ebp), %edx movl %edx, -16(%ebp) movl %edx, -16(%ebp) movl -8(%ebp), %ecx movl -8(%ebp), %ecx movl %ecx, -20(%ebp) movl %ecx, -20(%ebp) movl -16(%ebp), %edx movl -16(%ebp), %edx movl 8(%edx), %eax movl 8(%edx), %eax cmpl %eax, -20(%ebp) cmpl %eax, -20(%ebp) jb .L5 jb .L5 movl -20(%ebp), %ecx movl -20(%ebp), %ecx movl %ecx, (%esp) movl %ecx, (%esp) call _Jv_ThrowBadArrayIndex call _Jv_ThrowBadArrayIndex .L5: .L5: movl -12(%ebp), %eax movl -12(%ebp), %eax movl -20(%ebp), %edx movl -20(%ebp), %edx movl -16(%ebp), %ecx movl -16(%ebp), %ecx addl 12(%ecx,%edx,4), %eax addl 12(%ecx,%edx,4), %eax movl %eax, -4(%ebp) movl %eax, -4(%ebp) leal -8(%ebp), %eax leal -8(%ebp), %eax incl (%eax) incl (%eax) jmp .L2 jmp .L2 .L7: .L7: movl -4(%ebp), %eax movl -4(%ebp), %eax leave leave ret ret
push ebp push ebp ebp <- esp ebp <- esp esp <- esp - 24 esp <- esp - 24 s <- 0 (stack) s <- 0 (stack) i <- 0 (stack) i <- 0 (stack) compare i and 9 compare i and 9 jump to L4 if i <= 9 jump to L4 if i <= 9 jump to L7 jump to L7
Prologue
eax <- s eax <- s S[-12] <- eax (s in S[-12]) S[-12] <- eax (s in S[-12]) edx <- a edx <- a S[-16] <- edx (a in S[-16]) S[-16] <- edx (a in S[-16]) ecx <- i ecx <- i S[-20] <- ecx (i in S[-20]) S[-20] <- ecx (i in S[-20]) edx <- a edx <- a eax <- a.length eax <- a.length compare i and eax compare i and eax jump s[-20]/i < eax jump s[-20]/i < eax ecx <- i ecx <- i S[esp] <- ecx S[esp] <- ecx exception exception eax <- s eax <- s edx <- i edx <- i ecx <- a ecx <- a eax <- eax + M[exc + 4 * edx + 12] eax <- eax + M[exc + 4 * edx + 12] s <- eax; s <- eax; eax <- &i eax <- &i i <- i + 1; i <- i + 1; eax = s; eax = s;
Checks
Access
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
18
Java 2 x86
pushl %ebp push ebp pushl %ebp push ebp movl %esp, %ebp movl %esp, %ebp ebp <- esp ebp <- esp subl $24, %esp esp <- esp --24 subl $24, %esp esp <- esp 24 movl $0, -4(%ebp) ss<- 0 (stack) movl $0, -4(%ebp) <- 0 (stack) movl $0, -8(%ebp) ii<- 0 (stack) movl $0, -8(%ebp) <- 0 (stack) .L2: .L2: cmpl $9, -8(%ebp) cmpl $9, -8(%ebp) jle .L4 L4 if ii<= 9 jle .L4 L4 if <= 9 jmp .L7 jump to L7 jmp .L7 jump to L7 .L4 .L4 . . .L7: .L7: movl -4(%ebp), %eax eax = s; movl -4(%ebp), %eax eax = s; leave leave ret ret
CS-034: Lecture 7 (twd/pvh: 2005)
stack space!
3/16/2005
19
Java 2 x86
.L4: .L4: movl -4(%ebp), %eax movl -4(%ebp), %eax movl %eax, -12(%ebp) movl %eax, -12(%ebp) movl 12(%ebp), %edx movl 12(%ebp), %edx movl %edx, -16(%ebp) movl %edx, -16(%ebp) movl -8(%ebp), %ecx movl -8(%ebp), %ecx movl %ecx, -20(%ebp) movl %ecx, -20(%ebp) movl -16(%ebp), %edx movl -16(%ebp), %edx movl 8(%edx), %eax movl 8(%edx), %eax cmpl %eax, -20(%ebp) cmpl %eax, -20(%ebp) jb .L5 jb .L5 movl -20(%ebp), %ecx movl -20(%ebp), %ecx movl %ecx, (%esp) movl %ecx, (%esp) call _Jv_ThrowBadArrayIndex call _Jv_ThrowBadArrayIndex
3/16/2005
eax <- ss eax <S[-12] <- eax (s in S[-12]) S[-12] <- eax (s in S[-12]) edx <- a edx <- a S[-16] <- edx (a in S[-16]) S[-16] <- edx (a in S[-16]) ecx <- ii ecx <S[-20] <- ecx (i in S[-20]) S[-20] <- ecx (i in S[-20]) edx <- a edx <- a eax <- a.length eax <- a.length compare iiand eax compare and eax jump s[-20]/i < eax jump s[-20]/i < eax ecx <- ii ecx <S[esp] <- ecx S[esp] <- ecx exception exception
20
CS-034: Lecture 7 (twd/pvh: 2005)
Java 2 x86
.L4: .L4: movl movl movl movl -16(%ebp), %edx -16(%ebp), %edx 8(%edx), %eax 8(%edx), %eax edx <- a edx <- a eax <- a.length eax <- a.length
The array in Java is an object!
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
21
Java 2 x86
.L5: .L5: movl -12(%ebp), %eax eax <- ss movl -12(%ebp), %eax eax <movl -20(%ebp), %edx edx <- ii movl -20(%ebp), %edx edx <movl -16(%ebp), %ecx ecx <- a movl -16(%ebp), %ecx ecx <- a addl 12(%ecx,%edx,4), addl %eax 12(%ecx,%edx,4), %eax eax<-eax+M[exc+4*edx+12] eax<-eax+M[exc+4*edx+12] movl %eax, -4(%ebp) ss<- eax; movl %eax, -4(%ebp) <- eax; leal -8(%ebp), %eax eax <- &i leal -8(%ebp), %eax eax <- &i incl (%eax) ii<- ii+ 1; incl (%eax) <- + 1; jmp .L2 jmp .L2 What the $#$$% is this 12?
3/16/2005 CS-034: Lecture 7 (twd/pvh: 2005) 22
Arrays
Big differences in efficiency between C/C++ and Java between
C arrays are just pointers Java arrays
objects objects bound checking bound
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
23
More on Arrays in Java
class Foo {{int get() {{return 3; }} class Foo int get() return 3; }} class Bar extends Foo {{int get() {{return 6;}} class Bar extends Foo int get() return 6;}} public class Array {{ public class Array public static void main(String[] args) {{ public static void main(String[] args) Bar[] a = new Bar[10]; Bar[] a = new Bar[10]; Foo[] b = a; Foo[] b = a; b[3] = new Foo(); b[3] = new Foo(); System.out.println(b[3].get()); System.out.println(b[3].get()); }} }} Java compiles this program!
3/16/2005 CS-034: Lecture 7 (twd/pvh: 2005) 24
More on Arrays in Java
movl %ebx, 4(%esp) movl %ebx, 4(%esp) movl %esi, (%esp) movl %esi, (%esp) call _Jv_CheckArrayStore call _Jv_CheckArrayStore cmpb $0, -9(%ebp) cmpb $0, -9(%ebp) movl %ebx, 24(%esi) movl %ebx, 24(%esi) je .L8 je .L8 Every store in an array has a runtime check!
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
25
C 2 x86
class Stack {{ class Stack int a[100]; int a[100]; int top; int top; public: public: Stack() ::top(-1) {} Stack() top(-1) {} void push(int i) {{a[++top] = i; }} void push(int i) a[++top] = i; int pop() {{return a[top--]; }} int pop() return a[top--]; }; }; void g(Stack* s) {{ void g(Stack* s) int ii= 0; int = 0; while (i < 10) while (i < 10) s->push(i++); s->push(i++); }}
How is g compiled?
3/16/2005 CS-034: Lecture 7 (twd/pvh: 2005) 26
pushl %ebp pushl %ebp xorl %ecx, %ecx xorl %ecx, %ecx movl %esp, %ebp movl %esp, %ebp pushl %ebx pushl %ebx movl 8(%ebp), %ebx movl 8(%ebp), %ebx movl 400(%ebx), %edx movl 400(%ebx), %edx .L6: .L6: movl %ecx, %eax movl %ecx, %eax incl %edx incl %edx incl %ecx incl %ecx movl %eax, (%ebx,%edx,4) movl %eax, (%ebx,%edx,4) cmpl $9, %ecx cmpl $9, %ecx jle .L6 jle .L6 movl %edx, 400(%ebx) movl %edx, 400(%ebx) popl %ebx popl %ebx popl %ebp popl %ebp ret ret
3/16/2005
ecx <- 0 C 2 x86ecx <- 0esp ebp <-
Why two incl? push ebp push ebp
ebp <- esp push ebx (save ebx) push ebx (save ebx) ebx <- ss ebx <edx <- top edx <- top eax <- ecx/i eax <- ecx/i edx <- edx + 1 edx <- edx + 1 ecx <- ecx + 1 ecx <- ecx + 1 eax/i -> S[ebx+4*edx/top] eax/i -> S[ebx+4*edx/top] jump if ecx/i <= 9 jump if ecx/i <= 9 top <- edx; top <- edx; ebx <- pop (restore ebx) ebx <- pop (restore ebx) ebp <- pop ebp <- pop
CS-034: Lecture 7 (twd/pvh: 2005)
27
Compiler Optimizations
Inlining
compilers remove function calls compilers replace them with the body of the function replace
The call to push is removed
direct manipulation of the stack direct top: offset 400 top:
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
28
C 2 x86
class Stack {{ class Stack int a[100]; int a[100]; int top; int top; public: public: Stack() ::top(-1) {} Stack() top(-1) {} virtual void push(int i) {{a[++top] = i; }} virtual void push(int i) a[++top] = i; int pop() {{return a[top--]; }} int pop() return a[top--]; }; };
3/16/2005
CS-034: Lecture 7 (twd/pvh: 2005)
29
Stack
VTBL
push VTBL of Stack
a[0]
a[99] top
3/16/2005 CS-034: Lecture 7 (twd/pvh: 2005) 30
pushl %ebp pushl %ebp movl %esp, %ebp movl %esp, %ebp pushl %esi pushl %esi pushl %ebx pushl %ebx subl $16, %esp subl $16, %esp xorl %ebx, %ebx xorl %ebx, %ebx movl 8(%ebp), %esi movl 8(%ebp), %esi .L5: .L5: movl (%esi), %eax movl (%esi), %eax movl %ebx, 4(%esp) movl %ebx, 4(%esp) incl %ebx incl %ebx movl %esi, (%esp) movl %esi, (%esp) call *(%eax) call *(%eax) cmpl $9, %ebx cmpl $9, %ebx jle .L5 jle .L5 addl $16, %esp addl $16, %esp popl %ebx popl %ebx popl %esi popl %esi popl %ebp popl %ebp ret ret
3/16/2005
C 2 x86
No inlining!
push ebp push ebp ebp <- esp ebp <- esp push esi push esi push ebx push ebx eps <- eps --16 eps <- eps 16 ebx <- 0 ebx <- 0 esi <- &s esi <- &s eax <- *(&s) [vtbl] eax <- *(&s) [vtbl] S[4] <- ebx/i S[4] <- ebx/i ebx <- ebx + 1; ebx <- ebx + 1; S[0] <- esi/s S[0] <- esi/s call the routine stored in %eax call the routine stored in %eax compare ebx and $9 compare ebx and $9 jump jump restore the stack restore the stack restore ebx restore ebx restore esi restore esi restore ebp restore ebp
31
CS-034: Lecture 7 (twd/pvh: 2005)
pushl %ebp push ebp pushl %ebp push ebp movl %esp, %ebp ebp <- esp movl %esp, %ebp ebp <- esp pushl %esi push esi pushl %esi push esi pushl %ebx push ebx pushl %ebx push ebx subl $16, %esp eps <- eps --16 subl $16, %esp eps <- eps 16 xorl %ebx, %ebx ebx <- 00 xorl %ebx, %ebx ebx <movl 8(%ebp), %esi esi <- &s movl 8(%ebp), %esi esi <- &s .L5: .L5: movl (%esi), %eax eax <- *(&s) [vtbl] movl (%esi), %eax eax <- *(&s) [vtbl] movl %ebx, 4(%esp) S[4] <- ebx/i movl %ebx, 4(%esp) S[4] <- ebx/i incl %ebx ebx <- ebx + 1; incl %ebx ebx <- ebx + 1; movl %esi, (%esp) S[0] <- esi/s movl %esi, (%esp) S[0] <- esi/s call *(%eax) call the routine stored in %eax call *(%eax) call the routine stored in %eax cmpl $9, %ebx compare ebx and $9 cmpl $9, %ebx compare ebx and $9 jle .L5 jump jle .L5 jump addl $16, %esp restore the stack addl $16, %esp restore the stack popl %ebx restore ebx popl %ebx restore ebx popl %esi restore esi popl %esi restore esi popl %ebp restore ebp popl %ebp restore ebp ret 3/16/2005 CS-034: Lecture 7 (twd/pvh: 2005) 32 ret
C 2 x86
C 2 x86
push: push: pushl pushl movl movl movl movl movl movl movl movl incl incl movl movl movl movl popl popl ret ret
3/16/2005
why the 4?
%ebp %ebp %esp, %ebp %esp, %ebp 8(%ebp), %eax 8(%ebp), %eax 12(%ebp), %edx 12(%ebp), %edx 404(%eax), %ecx 404(%eax), %ecx %ecx %ecx %ecx, 404(%eax) %ecx, 404(%eax) %edx, 4(%eax,%ecx,4) %edx, 4(%eax,%ecx,4) %ebp %ebp
eax <- &s eax <- &s edx <- ii edx <ecx <- top; ecx <- top; ecx++; ecx++; top <- ecx top <- ecx a[4*ecx] <- ii a[4*ecx] <-
CS-034: Lecture 7 (twd/pvh: 2005)
33
void swap(int& a,int& b) void swap(int& a,int& b) {{ where is tmp? int tmp = a; int tmp = a; a = b; a = b; swap swap b = tmp; b = tmp; pushl %ebp push ebp pushl %ebp push ebp }} movl %esp, %ebp ebp <- esp movl %esp, %ebp ebp <- esp movl 8(%ebp), %edx edx <- &am...