Analytical Modeling of System Temperature

Results

Nops test

nops test

This is a while loop with a single nop inside it.

08048394 <main>:
 8048394:       8d 4c 24 04             lea    0x4(%esp),%ecx
 8048398:       83 e4 f0                and    $0xfffffff0,%esp
 804839b:       ff 71 fc                pushl  -0x4(%ecx)
 804839e:       55                      push   %ebp
 804839f:       89 e5                   mov    %esp,%ebp
 80483a1:       51                      push   %ecx
 80483a2:       83 ec 10                sub    $0x10,%esp
 80483a5:       c7 45 f8 00 00 00 00    movl   $0x0,-0x8(%ebp)
 80483ac:       90                      nop    
 80483ad:       eb fd                   jmp    80483ac <main+0x18>
 80483af:       90                      nop    

Integer Operations

int add test

This is a while loop with a single x++ in it.

08048394 <main>:
 8048394:       8d 4c 24 04             lea    0x4(%esp),%ecx
 8048398:       83 e4 f0                and    $0xfffffff0,%esp
 804839b:       ff 71 fc                pushl  -0x4(%ecx)
 804839e:       55                      push   %ebp
 804839f:       89 e5                   mov    %esp,%ebp
 80483a1:       51                      push   %ecx
 80483a2:       83 ec 10                sub    $0x10,%esp
 80483a5:       c7 45 f8 00 00 00 00    movl   $0x0,-0x8(%ebp)
 80483ac:       83 45 f8 01             addl   $0x1,-0x8(%ebp)
 80483b0:       eb f3                   jmp    80483a5 <main+0x11>
 80483b2:       90                      nop    
 80483b3:       90                      nop    
 80483b4:       90                      nop    
 80483b5:       90                      nop    
 80483b6:       90                      nop    
 80483b7:       90                      nop    
 80483b8:       90                      nop    
 80483b9:       90                      nop    
 80483ba:       90                      nop    
 80483bb:       90                      nop    
 80483bc:       90                      nop    
 80483bd:       90                      nop    
 80483be:       90                      nop    
 80483bf:       90                      nop    
int sub test

A while loop with a single x– in it.

08048394 <main>:
 8048394:       8d 4c 24 04             lea    0x4(%esp),%ecx
 8048398:       83 e4 f0                and    $0xfffffff0,%esp
 804839b:       ff 71 fc                pushl  -0x4(%ecx)
 804839e:       55                      push   %ebp
 804839f:       89 e5                   mov    %esp,%ebp
 80483a1:       51                      push   %ecx
 80483a2:       83 ec 10                sub    $0x10,%esp
 80483a5:       c7 45 f8 02 00 00 00    movl   $0x2,-0x8(%ebp)
 80483ac:       83 6d f8 01             subl   $0x1,-0x8(%ebp)
 80483b0:       eb f3                   jmp    80483a5 <main+0x11>
 80483b2:       90                      nop    
 80483b3:       90                      nop    
 80483b4:       90                      nop    
 80483b5:       90                      nop    
 80483b6:       90                      nop    
 80483b7:       90                      nop    
 80483b8:       90                      nop    
 80483b9:       90                      nop    
 80483ba:       90                      nop    
 80483bb:       90                      nop    
 80483bc:       90                      nop    
 80483bd:       90                      nop    
 80483be:       90                      nop    
 80483bf:       90                      nop    
int mul test

A while loop which takes two integers (x=54;y=82;) and multiplies them (z=x*y).

08048394 <main>:
 8048394:       8d 4c 24 04             lea    0x4(%esp),%ecx
 8048398:       83 e4 f0                and    $0xfffffff0,%esp
 804839b:       ff 71 fc                pushl  -0x4(%ecx)
 804839e:       55                      push   %ebp
 804839f:       89 e5                   mov    %esp,%ebp
 80483a1:       51                      push   %ecx
 80483a2:       83 ec 10                sub    $0x10,%esp
 80483a5:       c7 45 f8 36 00 00 00    movl   $0x36,-0x8(%ebp)
 80483ac:       c7 45 f4 52 00 00 00    movl   $0x52,-0xc(%ebp)
 80483b3:       8b 45 f8                mov    -0x8(%ebp),%eax
 80483b6:       0f af 45 f4             imul   -0xc(%ebp),%eax
 80483ba:       89 45 f0                mov    %eax,-0x10(%ebp)
 80483bd:       eb e6                   jmp    80483a5 <main+0x11>
 80483bf:       90                      nop    
int div test

A while loop which takes two integers (x=54;y=82;) and divides them (z=y/x).

08048394 <main>:
 8048394:       8d 4c 24 04             lea    0x4(%esp),%ecx
 8048398:       83 e4 f0                and    $0xfffffff0,%esp
 804839b:       ff 71 fc                pushl  -0x4(%ecx)
 804839e:       55                      push   %ebp
 804839f:       89 e5                   mov    %esp,%ebp
 80483a1:       51                      push   %ecx
 80483a2:       83 ec 18                sub    $0x18,%esp
 80483a5:       c7 45 f8 36 00 00 00    movl   $0x36,-0x8(%ebp)
 80483ac:       c7 45 f4 52 00 00 00    movl   $0x52,-0xc(%ebp)
 80483b3:       8b 45 f4                mov    -0xc(%ebp),%eax
 80483b6:       89 45 e4                mov    %eax,-0x1c(%ebp)
 80483b9:       8b 55 e4                mov    -0x1c(%ebp),%edx
 80483bc:       89 d0                   mov    %edx,%eax
 80483be:       c1 fa 1f                sar    $0x1f,%edx
 80483c1:       f7 7d f8                idivl  -0x8(%ebp)
 80483c4:       89 45 f0                mov    %eax,-0x10(%ebp)
 80483c7:       eb dc                   jmp    80483a5 <main+0x11>
 80483c9:       90                      nop    
 80483ca:       90                      nop    
 80483cb:       90                      nop    
 80483cc:       90                      nop    
 80483cd:       90                      nop    
 80483ce:       90                      nop    
 80483cf:       90                      nop    

FP Operations

fp add test

This is a while loop which takes two doubles and adds them just like in the int add test.

08048394 <main>:
 8048394:       8d 4c 24 04             lea    0x4(%esp),%ecx
 8048398:       83 e4 f0                and    $0xfffffff0,%esp
 804839b:       ff 71 fc                pushl  -0x4(%ecx)
 804839e:       55                      push   %ebp
 804839f:       89 e5                   mov    %esp,%ebp
 80483a1:       51                      push   %ecx
 80483a2:       83 ec 24                sub    $0x24,%esp
 80483a5:       dd 05 90 84 04 08       fldl   0x8048490
 80483ab:       dd 5d f0                fstpl  -0x10(%ebp)
 80483ae:       dd 05 98 84 04 08       fldl   0x8048498
 80483b4:       dd 5d e8                fstpl  -0x18(%ebp)
 80483b7:       dd 45 f0                fldl   -0x10(%ebp)
 80483ba:       dc 45 e8                faddl  -0x18(%ebp)
 80483bd:       dd 5d e0                fstpl  -0x20(%ebp)
 80483c0:       eb e3                   jmp    80483a5 <main+0x11>
 80483c2:       90                      nop    
 80483c3:       90                      nop    
 80483c4:       90                      nop    
 80483c5:       90                      nop    
 80483c6:       90                      nop    
 80483c7:       90                      nop    
 80483c8:       90                      nop    
 80483c9:       90                      nop    
 80483ca:       90                      nop    
 80483cb:       90                      nop    
 80483cc:       90                      nop    
 80483cd:       90                      nop    
 80483ce:       90                      nop    
 80483cf:       90                      nop    
fp sub test

A while loop which takes two doubles and subtracts them.

08048394 <main>:
 8048394:       8d 4c 24 04             lea    0x4(%esp),%ecx
 8048398:       83 e4 f0                and    $0xfffffff0,%esp
 804839b:       ff 71 fc                pushl  -0x4(%ecx)
 804839e:       55                      push   %ebp
 804839f:       89 e5                   mov    %esp,%ebp
 80483a1:       51                      push   %ecx
 80483a2:       83 ec 24                sub    $0x24,%esp
 80483a5:       dd 05 90 84 04 08       fldl   0x8048490
 80483ab:       dd 5d f0                fstpl  -0x10(%ebp)
 80483ae:       dd 05 98 84 04 08       fldl   0x8048498
 80483b4:       dd 5d e8                fstpl  -0x18(%ebp)
 80483b7:       dd 45 e8                fldl   -0x18(%ebp)
 80483ba:       dc 65 f0                fsubl  -0x10(%ebp)
 80483bd:       dd 5d e0                fstpl  -0x20(%ebp)
 80483c0:       eb e3                   jmp    80483a5 <main+0x11>
 80483c2:       90                      nop    
 80483c3:       90                      nop    
 80483c4:       90                      nop    
 80483c5:       90                      nop    
 80483c6:       90                      nop    
 80483c7:       90                      nop    
 80483c8:       90                      nop    
 80483c9:       90                      nop    
 80483ca:       90                      nop    
 80483cb:       90                      nop    
 80483cc:       90                      nop    
 80483cd:       90                      nop    
 80483ce:       90                      nop    
 80483cf:       90                      nop    
fp mul test

A while loop which takes two doubles and multiplies them. Within the loop, we take two doubles, so we are multiplying the same numbers again and again. This should avoid overflow.

08048394 <main>:
 8048394:       8d 4c 24 04             lea    0x4(%esp),%ecx
 8048398:       83 e4 f0                and    $0xfffffff0,%esp
 804839b:       ff 71 fc                pushl  -0x4(%ecx)
 804839e:       55                      push   %ebp
 804839f:       89 e5                   mov    %esp,%ebp
 80483a1:       51                      push   %ecx
 80483a2:       83 ec 24                sub    $0x24,%esp
 80483a5:       dd 05 90 84 04 08       fldl   0x8048490
 80483ab:       dd 5d f0                fstpl  -0x10(%ebp)
 80483ae:       dd 05 98 84 04 08       fldl   0x8048498
 80483b4:       dd 5d e8                fstpl  -0x18(%ebp)
 80483b7:       dd 45 f0                fldl   -0x10(%ebp)
 80483ba:       dc 4d e8                fmull  -0x18(%ebp)
 80483bd:       dd 5d e0                fstpl  -0x20(%ebp)
 80483c0:       eb e3                   jmp    80483a5 <main+0x11>
 80483c2:       90                      nop    
 80483c3:       90                      nop    
 80483c4:       90                      nop    
 80483c5:       90                      nop    
 80483c6:       90                      nop    
 80483c7:       90                      nop    
 80483c8:       90                      nop    
 80483c9:       90                      nop    
 80483ca:       90                      nop    
 80483cb:       90                      nop    
 80483cc:       90                      nop    
 80483cd:       90                      nop    
 80483ce:       90                      nop    
 80483cf:       90                      nop    
fp div test

A while loop which takes two doubles and divides them. The lower peak temperature w.r.t. fp mul test is due to lack of pipelining in the fp div FU.

08048394 <main>:
 8048394:       8d 4c 24 04             lea    0x4(%esp),%ecx
 8048398:       83 e4 f0                and    $0xfffffff0,%esp
 804839b:       ff 71 fc                pushl  -0x4(%ecx)
 804839e:       55                      push   %ebp
 804839f:       89 e5                   mov    %esp,%ebp
 80483a1:       51                      push   %ecx
 80483a2:       83 ec 24                sub    $0x24,%esp
 80483a5:       dd 05 90 84 04 08       fldl   0x8048490
 80483ab:       dd 5d f0                fstpl  -0x10(%ebp)
 80483ae:       dd 05 98 84 04 08       fldl   0x8048498
 80483b4:       dd 5d e8                fstpl  -0x18(%ebp)
 80483b7:       dd 45 e8                fldl   -0x18(%ebp)
 80483ba:       dc 75 f0                fdivl  -0x10(%ebp)
 80483bd:       dd 5d e0                fstpl  -0x20(%ebp)
 80483c0:       eb e3                   jmp    80483a5 <main+0x11>
 80483c2:       90                      nop    
 80483c3:       90                      nop    
 80483c4:       90                      nop    
 80483c5:       90                      nop    
 80483c6:       90                      nop    
 80483c7:       90                      nop    
 80483c8:       90                      nop    
 80483c9:       90                      nop    
 80483ca:       90                      nop    
 80483cb:       90                      nop    
 80483cc:       90                      nop    
 80483cd:       90                      nop    
 80483ce:       90                      nop    
 80483cf:       90                      nop    

Unrolled Integer Operations

unrolled int add test

This is a while loop with multiple x++s in it.

08048394 <main>:
 8048394:	8d 4c 24 04          	lea    0x4(%esp),%ecx
 8048398:	83 e4 f0             	and    $0xfffffff0,%esp
 804839b:	ff 71 fc             	pushl  -0x4(%ecx)
 804839e:	55                   	push   %ebp
 804839f:	89 e5                	mov    %esp,%ebp
 80483a1:	51                   	push   %ecx
 80483a2:	83 ec 10             	sub    $0x10,%esp
 80483a5:	c7 45 f8 00 00 00 00 	movl   $0x0,-0x8(%ebp)
 80483ac:	83 45 f8 01          	addl   $0x1,-0x8(%ebp)
 80483b0:	83 45 f8 01          	addl   $0x1,-0x8(%ebp)
 80483b4:	83 45 f8 01          	addl   $0x1,-0x8(%ebp)
 80483b8:	83 45 f8 01          	addl   $0x1,-0x8(%ebp)
 80483bc:	83 45 f8 01          	addl   $0x1,-0x8(%ebp)
 80483c0:	83 45 f8 01          	addl   $0x1,-0x8(%ebp)
 80483c4:	83 45 f8 01          	addl   $0x1,-0x8(%ebp)
 80483c8:	83 45 f8 01          	addl   $0x1,-0x8(%ebp)
 80483cc:	83 45 f8 01          	addl   $0x1,-0x8(%ebp)
 80483d0:	83 45 f8 01          	addl   $0x1,-0x8(%ebp)
 80483d4:	eb cf                	jmp    80483a5 <main+0x11>
 80483d6:	90                   	nop    
 80483d7:	90                   	nop    
 80483d8:	90                   	nop    
 80483d9:	90                   	nop    
 80483da:	90                   	nop    
 80483db:	90                   	nop    
 80483dc:	90                   	nop    
 80483dd:	90                   	nop    
 80483de:	90                   	nop    
 80483df:	90                   	nop    
unrolled int sub test

A while loop with multiple x–s in it.

08048394 <main>:
 8048394:	8d 4c 24 04          	lea    0x4(%esp),%ecx
 8048398:	83 e4 f0             	and    $0xfffffff0,%esp
 804839b:	ff 71 fc             	pushl  -0x4(%ecx)
 804839e:	55                   	push   %ebp
 804839f:	89 e5                	mov    %esp,%ebp
 80483a1:	51                   	push   %ecx
 80483a2:	83 ec 10             	sub    $0x10,%esp
 80483a5:	c7 45 f8 14 00 00 00 	movl   $0x14,-0x8(%ebp)
 80483ac:	83 6d f8 01          	subl   $0x1,-0x8(%ebp)
 80483b0:	83 6d f8 01          	subl   $0x1,-0x8(%ebp)
 80483b4:	83 6d f8 01          	subl   $0x1,-0x8(%ebp)
 80483b8:	83 6d f8 01          	subl   $0x1,-0x8(%ebp)
 80483bc:	83 6d f8 01          	subl   $0x1,-0x8(%ebp)
 80483c0:	83 6d f8 01          	subl   $0x1,-0x8(%ebp)
 80483c4:	83 6d f8 01          	subl   $0x1,-0x8(%ebp)
 80483c8:	83 6d f8 01          	subl   $0x1,-0x8(%ebp)
 80483cc:	83 6d f8 01          	subl   $0x1,-0x8(%ebp)
 80483d0:	83 6d f8 01          	subl   $0x1,-0x8(%ebp)
 80483d4:	eb cf                	jmp    80483a5 <main+0x11>
 80483d6:	90                   	nop    
 80483d7:	90                   	nop    
 80483d8:	90                   	nop    
 80483d9:	90                   	nop    
 80483da:	90                   	nop    
 80483db:	90                   	nop    
 80483dc:	90                   	nop    
 80483dd:	90                   	nop    
 80483de:	90                   	nop    
 80483df:	90                   	nop    
unrolled int mul test

A while loop which takes two integers and multiplies them multiple times within the same loop.

08048394 <main>:
 8048394:	8d 4c 24 04          	lea    0x4(%esp),%ecx
 8048398:	83 e4 f0             	and    $0xfffffff0,%esp
 804839b:	ff 71 fc             	pushl  -0x4(%ecx)
 804839e:	55                   	push   %ebp
 804839f:	89 e5                	mov    %esp,%ebp
 80483a1:	51                   	push   %ecx
 80483a2:	83 ec 10             	sub    $0x10,%esp
 80483a5:	c7 45 f8 36 00 00 00 	movl   $0x36,-0x8(%ebp)
 80483ac:	c7 45 f4 52 00 00 00 	movl   $0x52,-0xc(%ebp)
 80483b3:	8b 45 f8             	mov    -0x8(%ebp),%eax
 80483b6:	0f af 45 f4          	imul   -0xc(%ebp),%eax
 80483ba:	89 45 f0             	mov    %eax,-0x10(%ebp)
 80483bd:	8b 45 f8             	mov    -0x8(%ebp),%eax
 80483c0:	0f af 45 f4          	imul   -0xc(%ebp),%eax
 80483c4:	89 45 f0             	mov    %eax,-0x10(%ebp)
 80483c7:	8b 45 f8             	mov    -0x8(%ebp),%eax
 80483ca:	0f af 45 f4          	imul   -0xc(%ebp),%eax
 80483ce:	89 45 f0             	mov    %eax,-0x10(%ebp)
 80483d1:	8b 45 f8             	mov    -0x8(%ebp),%eax
 80483d4:	0f af 45 f4          	imul   -0xc(%ebp),%eax
 80483d8:	89 45 f0             	mov    %eax,-0x10(%ebp)
 80483db:	8b 45 f8             	mov    -0x8(%ebp),%eax
 80483de:	0f af 45 f4          	imul   -0xc(%ebp),%eax
 80483e2:	89 45 f0             	mov    %eax,-0x10(%ebp)
 80483e5:	8b 45 f8             	mov    -0x8(%ebp),%eax
 80483e8:	0f af 45 f4          	imul   -0xc(%ebp),%eax
 80483ec:	89 45 f0             	mov    %eax,-0x10(%ebp)
 80483ef:	8b 45 f8             	mov    -0x8(%ebp),%eax
 80483f2:	0f af 45 f4          	imul   -0xc(%ebp),%eax
 80483f6:	89 45 f0             	mov    %eax,-0x10(%ebp)
 80483f9:	8b 45 f8             	mov    -0x8(%ebp),%eax
 80483fc:	0f af 45 f4          	imul   -0xc(%ebp),%eax
 8048400:	89 45 f0             	mov    %eax,-0x10(%ebp)
 8048403:	8b 45 f8             	mov    -0x8(%ebp),%eax
 8048406:	0f af 45 f4          	imul   -0xc(%ebp),%eax
 804840a:	89 45 f0             	mov    %eax,-0x10(%ebp)
 804840d:	8b 45 f8             	mov    -0x8(%ebp),%eax
 8048410:	0f af 45 f4          	imul   -0xc(%ebp),%eax
 8048414:	89 45 f0             	mov    %eax,-0x10(%ebp)
 8048417:	eb 8c                	jmp    80483a5 <main+0x11>
 8048419:	90                   	nop    
 804841a:	90                   	nop    
 804841b:	90                   	nop    
 804841c:	90                   	nop    
 804841d:	90                   	nop    
 804841e:	90                   	nop    
 804841f:	90                   	nop    
unrolled int div test

A while loop which takes two integers and divides them multiple times in the same loop.

08048394 <main>:
 8048394:	8d 4c 24 04          	lea    0x4(%esp),%ecx
 8048398:	83 e4 f0             	and    $0xfffffff0,%esp
 804839b:	ff 71 fc             	pushl  -0x4(%ecx)
 804839e:	55                   	push   %ebp
 804839f:	89 e5                	mov    %esp,%ebp
 80483a1:	51                   	push   %ecx
 80483a2:	83 ec 3c             	sub    $0x3c,%esp
 80483a5:	c7 45 f8 36 00 00 00 	movl   $0x36,-0x8(%ebp)
 80483ac:	c7 45 f4 52 00 00 00 	movl   $0x52,-0xc(%ebp)
 80483b3:	8b 45 f4             	mov    -0xc(%ebp),%eax
 80483b6:	89 45 c0             	mov    %eax,-0x40(%ebp)
 80483b9:	8b 55 c0             	mov    -0x40(%ebp),%edx
 80483bc:	89 d0                	mov    %edx,%eax
 80483be:	c1 fa 1f             	sar    $0x1f,%edx
 80483c1:	f7 7d f8             	idivl  -0x8(%ebp)
 80483c4:	89 45 f0             	mov    %eax,-0x10(%ebp)
 80483c7:	8b 45 f4             	mov    -0xc(%ebp),%eax
 80483ca:	89 45 c0             	mov    %eax,-0x40(%ebp)
 80483cd:	8b 55 c0             	mov    -0x40(%ebp),%edx
 80483d0:	89 d0                	mov    %edx,%eax
 80483d2:	c1 fa 1f             	sar    $0x1f,%edx
 80483d5:	f7 7d f8             	idivl  -0x8(%ebp)
 80483d8:	89 45 f0             	mov    %eax,-0x10(%ebp)
 80483db:	8b 45 f4             	mov    -0xc(%ebp),%eax
 80483de:	89 45 c0             	mov    %eax,-0x40(%ebp)
 80483e1:	8b 55 c0             	mov    -0x40(%ebp),%edx
 80483e4:	89 d0                	mov    %edx,%eax
 80483e6:	c1 fa 1f             	sar    $0x1f,%edx
 80483e9:	f7 7d f8             	idivl  -0x8(%ebp)
 80483ec:	89 45 f0             	mov    %eax,-0x10(%ebp)
 80483ef:	8b 45 f4             	mov    -0xc(%ebp),%eax
 80483f2:	89 45 c0             	mov    %eax,-0x40(%ebp)
 80483f5:	8b 55 c0             	mov    -0x40(%ebp),%edx
 80483f8:	89 d0                	mov    %edx,%eax
 80483fa:	c1 fa 1f             	sar    $0x1f,%edx
 80483fd:	f7 7d f8             	idivl  -0x8(%ebp)
 8048400:	89 45 f0             	mov    %eax,-0x10(%ebp)
 8048403:	8b 45 f4             	mov    -0xc(%ebp),%eax
 8048406:	89 45 c0             	mov    %eax,-0x40(%ebp)
 8048409:	8b 55 c0             	mov    -0x40(%ebp),%edx
 804840c:	89 d0                	mov    %edx,%eax
 804840e:	c1 fa 1f             	sar    $0x1f,%edx
 8048411:	f7 7d f8             	idivl  -0x8(%ebp)
 8048414:	89 45 f0             	mov    %eax,-0x10(%ebp)
 8048417:	8b 45 f4             	mov    -0xc(%ebp),%eax
 804841a:	89 45 c0             	mov    %eax,-0x40(%ebp)
 804841d:	8b 55 c0             	mov    -0x40(%ebp),%edx
 8048420:	89 d0                	mov    %edx,%eax
 8048422:	c1 fa 1f             	sar    $0x1f,%edx
 8048425:	f7 7d f8             	idivl  -0x8(%ebp)
 8048428:	89 45 f0             	mov    %eax,-0x10(%ebp)
 804842b:	8b 45 f4             	mov    -0xc(%ebp),%eax
 804842e:	89 45 c0             	mov    %eax,-0x40(%ebp)
 8048431:	8b 55 c0             	mov    -0x40(%ebp),%edx
 8048434:	89 d0                	mov    %edx,%eax
 8048436:	c1 fa 1f             	sar    $0x1f,%edx
 8048439:	f7 7d f8             	idivl  -0x8(%ebp)
 804843c:	89 45 f0             	mov    %eax,-0x10(%ebp)
 804843f:	8b 45 f4             	mov    -0xc(%ebp),%eax
 8048442:	89 45 c0             	mov    %eax,-0x40(%ebp)
 8048445:	8b 55 c0             	mov    -0x40(%ebp),%edx
 8048448:	89 d0                	mov    %edx,%eax
 804844a:	c1 fa 1f             	sar    $0x1f,%edx
 804844d:	f7 7d f8             	idivl  -0x8(%ebp)
 8048450:	89 45 f0             	mov    %eax,-0x10(%ebp)
 8048453:	8b 45 f4             	mov    -0xc(%ebp),%eax
 8048456:	89 45 c0             	mov    %eax,-0x40(%ebp)
 8048459:	8b 55 c0             	mov    -0x40(%ebp),%edx
 804845c:	89 d0                	mov    %edx,%eax
 804845e:	c1 fa 1f             	sar    $0x1f,%edx
 8048461:	f7 7d f8             	idivl  -0x8(%ebp)
 8048464:	89 45 f0             	mov    %eax,-0x10(%ebp)
 8048467:	8b 45 f4             	mov    -0xc(%ebp),%eax
 804846a:	89 45 c0             	mov    %eax,-0x40(%ebp)
 804846d:	8b 55 c0             	mov    -0x40(%ebp),%edx
 8048470:	89 d0                	mov    %edx,%eax
 8048472:	c1 fa 1f             	sar    $0x1f,%edx
 8048475:	f7 7d f8             	idivl  -0x8(%ebp)
 8048478:	89 45 f0             	mov    %eax,-0x10(%ebp)
 804847b:	e9 25 ff ff ff       	jmp    80483a5 <main+0x11>

Unrolled FP Operations

unrolled fp add test

This is a while loop which takes two doubles and adds them multiple times in the same loop just like in the unrolled int add test.

08048394 <main>:
 8048394:	8d 4c 24 04          	lea    0x4(%esp),%ecx
 8048398:	83 e4 f0             	and    $0xfffffff0,%esp
 804839b:	ff 71 fc             	pushl  -0x4(%ecx)
 804839e:	55                   	push   %ebp
 804839f:	89 e5                	mov    %esp,%ebp
 80483a1:	51                   	push   %ecx
 80483a2:	83 ec 24             	sub    $0x24,%esp
 80483a5:	dd 05 e0 84 04 08    	fldl   0x80484e0
 80483ab:	dd 5d f0             	fstpl  -0x10(%ebp)
 80483ae:	dd 05 e8 84 04 08    	fldl   0x80484e8
 80483b4:	dd 5d e8             	fstpl  -0x18(%ebp)
 80483b7:	dd 45 e8             	fldl   -0x18(%ebp)
 80483ba:	dc 45 f0             	faddl  -0x10(%ebp)
 80483bd:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483c0:	dd 45 e8             	fldl   -0x18(%ebp)
 80483c3:	dc 45 f0             	faddl  -0x10(%ebp)
 80483c6:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483c9:	dd 45 e8             	fldl   -0x18(%ebp)
 80483cc:	dc 45 f0             	faddl  -0x10(%ebp)
 80483cf:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483d2:	dd 45 e8             	fldl   -0x18(%ebp)
 80483d5:	dc 45 f0             	faddl  -0x10(%ebp)
 80483d8:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483db:	dd 45 e8             	fldl   -0x18(%ebp)
 80483de:	dc 45 f0             	faddl  -0x10(%ebp)
 80483e1:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483e4:	dd 45 e8             	fldl   -0x18(%ebp)
 80483e7:	dc 45 f0             	faddl  -0x10(%ebp)
 80483ea:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483ed:	dd 45 e8             	fldl   -0x18(%ebp)
 80483f0:	dc 45 f0             	faddl  -0x10(%ebp)
 80483f3:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483f6:	dd 45 e8             	fldl   -0x18(%ebp)
 80483f9:	dc 45 f0             	faddl  -0x10(%ebp)
 80483fc:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483ff:	dd 45 e8             	fldl   -0x18(%ebp)
 8048402:	dc 45 f0             	faddl  -0x10(%ebp)
 8048405:	dd 5d e0             	fstpl  -0x20(%ebp)
 8048408:	dd 45 e8             	fldl   -0x18(%ebp)
 804840b:	dc 45 f0             	faddl  -0x10(%ebp)
 804840e:	dd 5d e0             	fstpl  -0x20(%ebp)
 8048411:	eb 92                	jmp    80483a5 <main+0x11>
 8048413:	90                   	nop    
 8048414:	90                   	nop    
 8048415:	90                   	nop    
 8048416:	90                   	nop    
 8048417:	90                   	nop    
 8048418:	90                   	nop    
 8048419:	90                   	nop    
 804841a:	90                   	nop    
 804841b:	90                   	nop    
 804841c:	90                   	nop    
 804841d:	90                   	nop    
 804841e:	90                   	nop    
 804841f:	90                   	nop    
unrolled fp sub test

A while loop which takes two doubles and subtracts them multiple times in the same loop.

08048394 <main>:
 8048394:	8d 4c 24 04          	lea    0x4(%esp),%ecx
 8048398:	83 e4 f0             	and    $0xfffffff0,%esp
 804839b:	ff 71 fc             	pushl  -0x4(%ecx)
 804839e:	55                   	push   %ebp
 804839f:	89 e5                	mov    %esp,%ebp
 80483a1:	51                   	push   %ecx
 80483a2:	83 ec 24             	sub    $0x24,%esp
 80483a5:	dd 05 e0 84 04 08    	fldl   0x80484e0
 80483ab:	dd 5d f0             	fstpl  -0x10(%ebp)
 80483ae:	dd 05 e8 84 04 08    	fldl   0x80484e8
 80483b4:	dd 5d e8             	fstpl  -0x18(%ebp)
 80483b7:	dd 45 e8             	fldl   -0x18(%ebp)
 80483ba:	dc 65 f0             	fsubl  -0x10(%ebp)
 80483bd:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483c0:	dd 45 e8             	fldl   -0x18(%ebp)
 80483c3:	dc 65 f0             	fsubl  -0x10(%ebp)
 80483c6:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483c9:	dd 45 e8             	fldl   -0x18(%ebp)
 80483cc:	dc 65 f0             	fsubl  -0x10(%ebp)
 80483cf:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483d2:	dd 45 e8             	fldl   -0x18(%ebp)
 80483d5:	dc 65 f0             	fsubl  -0x10(%ebp)
 80483d8:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483db:	dd 45 e8             	fldl   -0x18(%ebp)
 80483de:	dc 65 f0             	fsubl  -0x10(%ebp)
 80483e1:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483e4:	dd 45 e8             	fldl   -0x18(%ebp)
 80483e7:	dc 65 f0             	fsubl  -0x10(%ebp)
 80483ea:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483ed:	dd 45 e8             	fldl   -0x18(%ebp)
 80483f0:	dc 65 f0             	fsubl  -0x10(%ebp)
 80483f3:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483f6:	dd 45 e8             	fldl   -0x18(%ebp)
 80483f9:	dc 65 f0             	fsubl  -0x10(%ebp)
 80483fc:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483ff:	dd 45 e8             	fldl   -0x18(%ebp)
 8048402:	dc 65 f0             	fsubl  -0x10(%ebp)
 8048405:	dd 5d e0             	fstpl  -0x20(%ebp)
 8048408:	dd 45 e8             	fldl   -0x18(%ebp)
 804840b:	dc 65 f0             	fsubl  -0x10(%ebp)
 804840e:	dd 5d e0             	fstpl  -0x20(%ebp)
 8048411:	eb 92                	jmp    80483a5 <main+0x11>
 8048413:	90                   	nop    
 8048414:	90                   	nop    
 8048415:	90                   	nop    
 8048416:	90                   	nop    
 8048417:	90                   	nop    
 8048418:	90                   	nop    
 8048419:	90                   	nop    
 804841a:	90                   	nop    
 804841b:	90                   	nop    
 804841c:	90                   	nop    
 804841d:	90                   	nop    
 804841e:	90                   	nop    
 804841f:	90                   	nop    
unrolled fp mul test

A while loop which takes two doubles and multiplies them multiple times in the same loop. As in the case of fp mul test, we avoid overflow.

08048394 <main>:
 8048394:	8d 4c 24 04          	lea    0x4(%esp),%ecx
 8048398:	83 e4 f0             	and    $0xfffffff0,%esp
 804839b:	ff 71 fc             	pushl  -0x4(%ecx)
 804839e:	55                   	push   %ebp
 804839f:	89 e5                	mov    %esp,%ebp
 80483a1:	51                   	push   %ecx
 80483a2:	83 ec 24             	sub    $0x24,%esp
 80483a5:	dd 05 e0 84 04 08    	fldl   0x80484e0
 80483ab:	dd 5d f0             	fstpl  -0x10(%ebp)
 80483ae:	dd 05 e8 84 04 08    	fldl   0x80484e8
 80483b4:	dd 5d e8             	fstpl  -0x18(%ebp)
 80483b7:	dd 45 f0             	fldl   -0x10(%ebp)
 80483ba:	dc 4d e8             	fmull  -0x18(%ebp)
 80483bd:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483c0:	dd 45 f0             	fldl   -0x10(%ebp)
 80483c3:	dc 4d e8             	fmull  -0x18(%ebp)
 80483c6:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483c9:	dd 45 f0             	fldl   -0x10(%ebp)
 80483cc:	dc 4d e8             	fmull  -0x18(%ebp)
 80483cf:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483d2:	dd 45 f0             	fldl   -0x10(%ebp)
 80483d5:	dc 4d e8             	fmull  -0x18(%ebp)
 80483d8:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483db:	dd 45 f0             	fldl   -0x10(%ebp)
 80483de:	dc 4d e8             	fmull  -0x18(%ebp)
 80483e1:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483e4:	dd 45 f0             	fldl   -0x10(%ebp)
 80483e7:	dc 4d e8             	fmull  -0x18(%ebp)
 80483ea:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483ed:	dd 45 f0             	fldl   -0x10(%ebp)
 80483f0:	dc 4d e8             	fmull  -0x18(%ebp)
 80483f3:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483f6:	dd 45 f0             	fldl   -0x10(%ebp)
 80483f9:	dc 4d e8             	fmull  -0x18(%ebp)
 80483fc:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483ff:	dd 45 f0             	fldl   -0x10(%ebp)
 8048402:	dc 4d e8             	fmull  -0x18(%ebp)
 8048405:	dd 5d e0             	fstpl  -0x20(%ebp)
 8048408:	dd 45 f0             	fldl   -0x10(%ebp)
 804840b:	dc 4d e8             	fmull  -0x18(%ebp)
 804840e:	dd 5d e0             	fstpl  -0x20(%ebp)
 8048411:	eb 92                	jmp    80483a5 <main+0x11>
 8048413:	90                   	nop    
 8048414:	90                   	nop    
 8048415:	90                   	nop    
 8048416:	90                   	nop    
 8048417:	90                   	nop    
 8048418:	90                   	nop    
 8048419:	90                   	nop    
 804841a:	90                   	nop    
 804841b:	90                   	nop    
 804841c:	90                   	nop    
 804841d:	90                   	nop    
 804841e:	90                   	nop    
 804841f:	90                   	nop    
unrolled fp div test

A while loop which takes two doubles and divides them multiple times in the same loop.

08048394 <main>:
 8048394:	8d 4c 24 04          	lea    0x4(%esp),%ecx
 8048398:	83 e4 f0             	and    $0xfffffff0,%esp
 804839b:	ff 71 fc             	pushl  -0x4(%ecx)
 804839e:	55                   	push   %ebp
 804839f:	89 e5                	mov    %esp,%ebp
 80483a1:	51                   	push   %ecx
 80483a2:	83 ec 24             	sub    $0x24,%esp
 80483a5:	dd 05 e0 84 04 08    	fldl   0x80484e0
 80483ab:	dd 5d f0             	fstpl  -0x10(%ebp)
 80483ae:	dd 05 e8 84 04 08    	fldl   0x80484e8
 80483b4:	dd 5d e8             	fstpl  -0x18(%ebp)
 80483b7:	dd 45 e8             	fldl   -0x18(%ebp)
 80483ba:	dc 75 f0             	fdivl  -0x10(%ebp)
 80483bd:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483c0:	dd 45 e8             	fldl   -0x18(%ebp)
 80483c3:	dc 75 f0             	fdivl  -0x10(%ebp)
 80483c6:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483c9:	dd 45 e8             	fldl   -0x18(%ebp)
 80483cc:	dc 75 f0             	fdivl  -0x10(%ebp)
 80483cf:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483d2:	dd 45 e8             	fldl   -0x18(%ebp)
 80483d5:	dc 75 f0             	fdivl  -0x10(%ebp)
 80483d8:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483db:	dd 45 e8             	fldl   -0x18(%ebp)
 80483de:	dc 75 f0             	fdivl  -0x10(%ebp)
 80483e1:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483e4:	dd 45 e8             	fldl   -0x18(%ebp)
 80483e7:	dc 75 f0             	fdivl  -0x10(%ebp)
 80483ea:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483ed:	dd 45 e8             	fldl   -0x18(%ebp)
 80483f0:	dc 75 f0             	fdivl  -0x10(%ebp)
 80483f3:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483f6:	dd 45 e8             	fldl   -0x18(%ebp)
 80483f9:	dc 75 f0             	fdivl  -0x10(%ebp)
 80483fc:	dd 5d e0             	fstpl  -0x20(%ebp)
 80483ff:	dd 45 e8             	fldl   -0x18(%ebp)
 8048402:	dc 75 f0             	fdivl  -0x10(%ebp)
 8048405:	dd 5d e0             	fstpl  -0x20(%ebp)
 8048408:	dd 45 e8             	fldl   -0x18(%ebp)
 804840b:	dc 75 f0             	fdivl  -0x10(%ebp)
 804840e:	dd 5d e0             	fstpl  -0x20(%ebp)
 8048411:	eb 92                	jmp    80483a5 <main+0x11>
 8048413:	90                   	nop    
 8048414:	90                   	nop    
 8048415:	90                   	nop    
 8048416:	90                   	nop    
 8048417:	90                   	nop    
 8048418:	90                   	nop    
 8048419:	90                   	nop    
 804841a:	90                   	nop    
 804841b:	90                   	nop    
 804841c:	90                   	nop    
 804841d:	90                   	nop    
 804841e:	90                   	nop    
 804841f:	90                   	nop    

Linked-list Cache Miss Test

For a linked-list test, every cache miss depends on the previous cache miss. Thus, there is limited runahead.

cache miss with nops

We create a large linked-list and traverse through it (while loop) in an essentially pointer chasing manner. While the miss is being serviced, the machine executes nops (added in the assembly code before the end of each loop). We increase the number of nops in the loop to decrease the cache miss rate (more nops in loop implies more time between requests to memory for data). Thus, lower the cache miss rate, higher the number of nops executed per loop and thus, lower the peak temperature.

080483f4 <main>:
 80483f4:	8d 4c 24 04          	lea    0x4(%esp),%ecx
 80483f8:	83 e4 f0             	and    $0xfffffff0,%esp
 80483fb:	ff 71 fc             	pushl  -0x4(%ecx)
 80483fe:	55                   	push   %ebp
 80483ff:	89 e5                	mov    %esp,%ebp
 8048401:	51                   	push   %ecx
 8048402:	83 ec 44             	sub    $0x44,%esp
 8048405:	c7 44 24 04 04 00 00 	movl   $0x4,0x4(%esp)
 804840c:	00 
 804840d:	c7 04 24 55 90 04 08 	movl   $0x8049055,(%esp)
 8048414:	e8 13 ff ff ff       	call   804832c <printf@plt>
 8048419:	c7 44 24 04 40 00 00 	movl   $0x40,0x4(%esp)
 8048420:	00 
 8048421:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
 8048428:	e8 df fe ff ff       	call   804830c <calloc@plt>
 804842d:	89 45 f0             	mov    %eax,-0x10(%ebp)
 8048430:	8b 45 f0             	mov    -0x10(%ebp),%eax
 8048433:	89 45 ec             	mov    %eax,-0x14(%ebp)
 8048436:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
 804843d:	eb 34                	jmp    8048473 <main+0x7f>
 804843f:	c7 44 24 04 40 00 00 	movl   $0x40,0x4(%esp)
 8048446:	00 
 8048447:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
 804844e:	e8 b9 fe ff ff       	call   804830c <calloc@plt>
 8048453:	89 45 e8             	mov    %eax,-0x18(%ebp)
 8048456:	8b 45 e8             	mov    -0x18(%ebp),%eax
 8048459:	c7 40 3c 00 00 00 00 	movl   $0x0,0x3c(%eax)
 8048460:	8b 55 ec             	mov    -0x14(%ebp),%edx
 8048463:	8b 45 e8             	mov    -0x18(%ebp),%eax
 8048466:	89 42 3c             	mov    %eax,0x3c(%edx)
 8048469:	8b 45 e8             	mov    -0x18(%ebp),%eax
 804846c:	89 45 ec             	mov    %eax,-0x14(%ebp)
 804846f:	83 45 f4 01          	addl   $0x1,-0xc(%ebp)
 8048473:	81 7d f4 7f 96 98 00 	cmpl   $0x98967f,-0xc(%ebp)
 804847a:	7e c3                	jle    804843f <main+0x4b>
 804847c:	8b 45 ec             	mov    -0x14(%ebp),%eax
 804847f:	8b 55 f0             	mov    -0x10(%ebp),%edx
 8048482:	89 50 3c             	mov    %edx,0x3c(%eax)
 8048485:	8b 45 f0             	mov    -0x10(%ebp),%eax
 8048488:	89 45 ec             	mov    %eax,-0x14(%ebp)
 804848b:	e9 e7 0a 00 00       	jmp    8048f77 <main+0xb83>
 8048490:	8b 45 ec             	mov    -0x14(%ebp),%eax
 8048493:	8b 40 3c             	mov    0x3c(%eax),%eax
 8048496:	89 45 ec             	mov    %eax,-0x14(%ebp)
 8048499:	90                   	nop    
 804849a:	90                   	nop    
 804849b:	90                   	nop    

            //lots and lots of nops to vary cache miss rate

 8048f76:	90                   	nop    
 8048f77:	8b 45 ec             	mov    -0x14(%ebp),%eax
 8048f7a:	8b 40 3c             	mov    0x3c(%eax),%eax
 8048f7d:	85 c0                	test   %eax,%eax
 8048f7f:	0f 85 0b f5 ff ff    	jne    8048490 <main+0x9c>
 8048f85:	83 c4 44             	add    $0x44,%esp
 8048f88:	59                   	pop    %ecx
 8048f89:	5d                   	pop    %ebp
 8048f8a:	8d 61 fc             	lea    -0x4(%ecx),%esp
 8048f8d:	c3                   	ret    
 8048f8e:	90                   	nop    
 8048f8f:	90                   	nop    
cache miss with ops

Same as above except we now have some fp operations in each loop instead of nops. Thus, while a miss is being serviced, the system has work to do. We increase the amount of work to do in each loop to decrease the cache miss rate. Thus, lower the cache miss rate, more is the work done per loop and thus, higher the peak temperature. Note that this is also the expected behavior with cache misses. More the cache miss rate, more the amount of time spent in servicing them. Thus, cpu is stalled for more time. Thus, lower the peak temperature.

08048424 <main>:
 8048424:	8d 4c 24 04          	lea    0x4(%esp),%ecx
 8048428:	83 e4 f0             	and    $0xfffffff0,%esp
 804842b:	ff 71 fc             	pushl  -0x4(%ecx)
 804842e:	55                   	push   %ebp
 804842f:	89 e5                	mov    %esp,%ebp
 8048431:	53                   	push   %ebx
 8048432:	51                   	push   %ecx
 8048433:	83 ec 40             	sub    $0x40,%esp
 8048436:	89 cb                	mov    %ecx,%ebx
 8048438:	c7 44 24 04 04 00 00 	movl   $0x4,0x4(%esp)
 804843f:	00 
 8048440:	c7 04 24 e5 85 04 08 	movl   $0x80485e5,(%esp)
 8048447:	e8 04 ff ff ff       	call   8048350 <printf@plt>
 804844c:	c7 44 24 04 40 00 00 	movl   $0x40,0x4(%esp)
 8048453:	00 
 8048454:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
 804845b:	e8 d0 fe ff ff       	call   8048330 <calloc@plt>
 8048460:	89 45 f0             	mov    %eax,-0x10(%ebp)
 8048463:	8b 45 f0             	mov    -0x10(%ebp),%eax
 8048466:	89 45 ec             	mov    %eax,-0x14(%ebp)
 8048469:	8b 43 04             	mov    0x4(%ebx),%eax
 804846c:	83 c0 04             	add    $0x4,%eax
 804846f:	8b 00                	mov    (%eax),%eax
 8048471:	89 04 24             	mov    %eax,(%esp)
 8048474:	e8 e7 fe ff ff       	call   8048360 <atoi@plt>
 8048479:	89 45 e4             	mov    %eax,-0x1c(%ebp)
 804847c:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
 8048483:	eb 34                	jmp    80484b9 <main+0x95>
 8048485:	c7 44 24 04 40 00 00 	movl   $0x40,0x4(%esp)
 804848c:	00 
 804848d:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
 8048494:	e8 97 fe ff ff       	call   8048330 <calloc@plt>
 8048499:	89 45 e8             	mov    %eax,-0x18(%ebp)
 804849c:	8b 45 e8             	mov    -0x18(%ebp),%eax
 804849f:	c7 40 3c 00 00 00 00 	movl   $0x0,0x3c(%eax)
 80484a6:	8b 55 ec             	mov    -0x14(%ebp),%edx
 80484a9:	8b 45 e8             	mov    -0x18(%ebp),%eax
 80484ac:	89 42 3c             	mov    %eax,0x3c(%edx)
 80484af:	8b 45 e8             	mov    -0x18(%ebp),%eax
 80484b2:	89 45 ec             	mov    %eax,-0x14(%ebp)
 80484b5:	83 45 f4 01          	addl   $0x1,-0xc(%ebp)
 80484b9:	81 7d f4 7f 96 98 00 	cmpl   $0x98967f,-0xc(%ebp)
 80484c0:	7e c3                	jle    8048485 <main+0x61>
 80484c2:	8b 45 ec             	mov    -0x14(%ebp),%eax
 80484c5:	8b 55 f0             	mov    -0x10(%ebp),%edx
 80484c8:	89 50 3c             	mov    %edx,0x3c(%eax)
 80484cb:	8b 45 f0             	mov    -0x10(%ebp),%eax
 80484ce:	89 45 ec             	mov    %eax,-0x14(%ebp)
 80484d1:	eb 39                	jmp    804850c <main+0xe8>
 80484d3:	8b 45 ec             	mov    -0x14(%ebp),%eax
 80484d6:	8b 40 3c             	mov    0x3c(%eax),%eax
 80484d9:	89 45 ec             	mov    %eax,-0x14(%ebp)
 80484dc:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
 80484e3:	eb 1f                	jmp    8048504 <main+0xe0>
 80484e5:	dd 05 f0 85 04 08    	fldl   0x80485f0                 // work to do
 80484eb:	dd 5d d8             	fstpl  -0x28(%ebp)
 80484ee:	dd 05 f8 85 04 08    	fldl   0x80485f8
 80484f4:	dd 5d d0             	fstpl  -0x30(%ebp)
 80484f7:	dd 45 d8             	fldl   -0x28(%ebp)
 80484fa:	dc 4d d0             	fmull  -0x30(%ebp)
 80484fd:	dd 5d c8             	fstpl  -0x38(%ebp)
 8048500:	83 45 f4 01          	addl   $0x1,-0xc(%ebp)
 8048504:	8b 45 f4             	mov    -0xc(%ebp),%eax
 8048507:	3b 45 e4             	cmp    -0x1c(%ebp),%eax
 804850a:	7c d9                	jl     80484e5 <main+0xc1>       // jump back to do more work within the same loop
 804850c:	8b 45 ec             	mov    -0x14(%ebp),%eax
 804850f:	8b 40 3c             	mov    0x3c(%eax),%eax
 8048512:	85 c0                	test   %eax,%eax
 8048514:	75 bd                	jne    80484d3 <main+0xaf>       // end of one loop
 8048516:	83 c4 40             	add    $0x40,%esp
 8048519:	59                   	pop    %ecx
 804851a:	5b                   	pop    %ebx
 804851b:	5d                   	pop    %ebp
 804851c:	8d 61 fc             	lea    -0x4(%ecx),%esp
 804851f:	c3                   	ret    

Linked-list Branch Misprediction Test

We wrap a simple branching condition around the linked-list test. However, even though we may mispredict the branch and go ahead and fetch a cache miss, it might be useful later on. Thus, a mispredicted branch is not totally useless.

We use RAND_MAX-1 and RANDMAX/2 as our comparators against the random number generated. This creates different branch misprediction rates.

Results indicate that higher the branch misprediction rate, higher is the cpu peak temperature. We believe this to be due to the work done in flushing the pipelines.

08048424 <main>:
 8048424:	8d 4c 24 04          	lea    0x4(%esp),%ecx
 8048428:	83 e4 f0             	and    $0xfffffff0,%esp
 804842b:	ff 71 fc             	pushl  -0x4(%ecx)
 804842e:	55                   	push   %ebp
 804842f:	89 e5                	mov    %esp,%ebp
 8048431:	51                   	push   %ecx
 8048432:	83 ec 44             	sub    $0x44,%esp
 8048435:	c7 44 24 04 04 00 00 	movl   $0x4,0x4(%esp)
 804843c:	00 
 804843d:	c7 04 24 a5 85 04 08 	movl   $0x80485a5,(%esp)
 8048444:	e8 07 ff ff ff       	call   8048350 <printf@plt>
 8048449:	c7 44 24 04 40 00 00 	movl   $0x40,0x4(%esp)
 8048450:	00 
 8048451:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
 8048458:	e8 d3 fe ff ff       	call   8048330 <calloc@plt>
 804845d:	89 45 f0             	mov    %eax,-0x10(%ebp)
 8048460:	8b 45 f0             	mov    -0x10(%ebp),%eax
 8048463:	89 45 ec             	mov    %eax,-0x14(%ebp)
 8048466:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
 804846d:	eb 34                	jmp    80484a3 <main+0x7f>
 804846f:	c7 44 24 04 40 00 00 	movl   $0x40,0x4(%esp)
 8048476:	00 
 8048477:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
 804847e:	e8 ad fe ff ff       	call   8048330 <calloc@plt>
 8048483:	89 45 e8             	mov    %eax,-0x18(%ebp)
 8048486:	8b 45 e8             	mov    -0x18(%ebp),%eax
 8048489:	c7 40 3c 00 00 00 00 	movl   $0x0,0x3c(%eax)
 8048490:	8b 55 ec             	mov    -0x14(%ebp),%edx
 8048493:	8b 45 e8             	mov    -0x18(%ebp),%eax
 8048496:	89 42 3c             	mov    %eax,0x3c(%edx)
 8048499:	8b 45 e8             	mov    -0x18(%ebp),%eax
 804849c:	89 45 ec             	mov    %eax,-0x14(%ebp)
 804849f:	83 45 f4 01          	addl   $0x1,-0xc(%ebp)
 80484a3:	81 7d f4 7f 96 98 00 	cmpl   $0x98967f,-0xc(%ebp)
 80484aa:	7e c3                	jle    804846f <main+0x4b>
 80484ac:	8b 45 ec             	mov    -0x14(%ebp),%eax
 80484af:	8b 55 f0             	mov    -0x10(%ebp),%edx
 80484b2:	89 50 3c             	mov    %edx,0x3c(%eax)
 80484b5:	8b 45 f0             	mov    -0x10(%ebp),%eax
 80484b8:	89 45 ec             	mov    %eax,-0x14(%ebp)
 80484bb:	e8 a0 fe ff ff       	call   8048360 <rand@plt>
 80484c0:	89 45 f4             	mov    %eax,-0xc(%ebp)
 80484c3:	81 7d f4 fe ff ff 3f 	cmpl   $0x3ffffffe,-0xc(%ebp) // This is RAND_MAX/2  used for the red plot.
 80484ca:	7f ef                	jg     80484bb <main+0x97>    // We use RAND_MAX-1 for the blue plot.
 80484cc:	8b 45 ec             	mov    -0x14(%ebp),%eax
 80484cf:	8b 40 3c             	mov    0x3c(%eax),%eax
 80484d2:	89 45 ec             	mov    %eax,-0x14(%ebp)
 80484d5:	eb e4                	jmp    80484bb <main+0x97>
 80484d7:	90                   	nop    
 80484d8:	90                   	nop    
 80484d9:	90                   	nop    
 80484da:	90                   	nop    
 80484db:	90                   	nop    
 80484dc:	90                   	nop    
 80484dd:	90                   	nop    
 80484de:	90                   	nop    
 80484df:	90                   	nop    

Array element-fetching Cache Miss Test

We create a huge array and load elements from it. A cache miss does not depend on the previous cache miss as was in the case of linked-list test. Again, we add nops to reduce the cache miss rate. Thus, lower the cache miss rate, lower is the peak temperature.

080483f4 <main>:
 80483f4:	8d 4c 24 04          	lea    0x4(%esp),%ecx
 80483f8:	83 e4 f0             	and    $0xfffffff0,%esp
 80483fb:	ff 71 fc             	pushl  -0x4(%ecx)
 80483fe:	55                   	push   %ebp
 80483ff:	89 e5                	mov    %esp,%ebp
 8048401:	51                   	push   %ecx
 8048402:	83 ec 24             	sub    $0x24,%esp
 8048405:	c7 44 24 04 04 00 00 	movl   $0x4,0x4(%esp)
 804840c:	00 
 804840d:	c7 04 24 25 87 04 08 	movl   $0x8048725,(%esp)
 8048414:	e8 13 ff ff ff       	call   804832c <printf@plt>
 8048419:	c7 44 24 04 04 00 00 	movl   $0x4,0x4(%esp)
 8048420:	00 
 8048421:	c7 04 24 00 00 90 01 	movl   $0x1900000,(%esp)
 8048428:	e8 df fe ff ff       	call   804830c <calloc@plt>
 804842d:	89 45 f8             	mov    %eax,-0x8(%ebp)
 8048430:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
 8048437:	eb 13                	jmp    804844c <main+0x58>
 8048439:	8b 45 f4             	mov    -0xc(%ebp),%eax
 804843c:	c1 e0 02             	shl    $0x2,%eax
 804843f:	03 45 f8             	add    -0x8(%ebp),%eax
 8048442:	c7 00 10 00 00 00    	movl   $0x10,(%eax)
 8048448:	83 45 f4 01          	addl   $0x1,-0xc(%ebp)
 804844c:	81 7d f4 ff ff 8f 01 	cmpl   $0x18fffff,-0xc(%ebp)
 8048453:	7e e4                	jle    8048439 <main+0x45>
 8048455:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
 804845c:	e9 e8 01 00 00       	jmp    8048649 <main+0x255>
 8048461:	8b 45 f4             	mov    -0xc(%ebp),%eax
 8048464:	c1 e0 02             	shl    $0x2,%eax
 8048467:	03 45 f8             	add    -0x8(%ebp),%eax
 804846a:	8b 00                	mov    (%eax),%eax
 804846c:	83 45 f4 10          	addl   $0x10,-0xc(%ebp)
 8048470:	90                   	nop    
 8048471:	90                   	nop    
 8048472:	90                   	nop    

                 \\ lots of nops to vary cache miss rate

 8048645:	90                   	nop    
 8048646:	90                   	nop    
 8048647:	90                   	nop    
 8048648:	90                   	nop    
 8048649:	81 7d f4 ff ff 8f 01 	cmpl   $0x18fffff,-0xc(%ebp)
 8048650:	0f 8e 0b fe ff ff    	jle    8048461 <main+0x6d>
 8048656:	e9 fa fd ff ff       	jmp    8048455 <main+0x61>
 804865b:	90                   	nop    
 804865c:	90                   	nop    
 804865d:	90                   	nop    
 804865e:	90                   	nop    
 804865f:	90                   	nop    

Array element-fetching Branch Misprediction Test

We wrap a branch condition around the array cache miss code. In the 'if' part, we fetch the next element, in the 'else' part, we fetch the ((array_size/2)+1)st element. Since the array is large, a branch misprediction fetches useless data. Thus, we'll have to flush often (and thus stall more) for a higher branch misprediction rate. Reults indicate that higher the branch misprediction rate, lower is the peak temperature. Though this seems normal, the linked-list branch misprediction test suggested the opposite (not sure why).

08048454 <main>:
 8048454:	8d 4c 24 04          	lea    0x4(%esp),%ecx
 8048458:	83 e4 f0             	and    $0xfffffff0,%esp
 804845b:	ff 71 fc             	pushl  -0x4(%ecx)
 804845e:	55                   	push   %ebp
 804845f:	89 e5                	mov    %esp,%ebp
 8048461:	51                   	push   %ecx
 8048462:	83 ec 34             	sub    $0x34,%esp
 8048465:	c7 45 ec fd 5c 1e 6e 	movl   $0x6e1e5cfd,-0x14(%ebp)
 804846c:	c7 44 24 04 04 00 00 	movl   $0x4,0x4(%esp)
 8048473:	00 
 8048474:	c7 04 24 00 00 90 01 	movl   $0x1900000,(%esp)
 804847b:	e8 dc fe ff ff       	call   804835c <calloc@plt>
 8048480:	89 45 e8             	mov    %eax,-0x18(%ebp)
 8048483:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
 804848a:	e8 ed fe ff ff       	call   804837c <time@plt>
 804848f:	89 04 24             	mov    %eax,(%esp)
 8048492:	e8 a5 fe ff ff       	call   804833c <srand@plt>
 8048497:	c7 45 f0 ef 03 00 00 	movl   $0x3ef,-0x10(%ebp)
 804849e:	c7 45 f8 00 00 00 00 	movl   $0x0,-0x8(%ebp)
 80484a5:	eb 31                	jmp    80484d8 <main+0x84>
 80484a7:	e8 e0 fe ff ff       	call   804838c <rand@plt>
 80484ac:	89 45 f4             	mov    %eax,-0xc(%ebp)
 80484af:	8b 45 f4             	mov    -0xc(%ebp),%eax
 80484b2:	3b 45 ec             	cmp    -0x14(%ebp),%eax
 80484b5:	7d 0d                	jge    80484c4 <main+0x70>
 80484b7:	8b 45 f8             	mov    -0x8(%ebp),%eax
 80484ba:	c1 e0 02             	shl    $0x2,%eax
 80484bd:	03 45 e8             	add    -0x18(%ebp),%eax
 80484c0:	8b 00                	mov    (%eax),%eax
 80484c2:	eb 10                	jmp    80484d4 <main+0x80>
 80484c4:	8b 45 f8             	mov    -0x8(%ebp),%eax
 80484c7:	05 00 00 c8 00       	add    $0xc80000,%eax
 80484cc:	c1 e0 02             	shl    $0x2,%eax
 80484cf:	03 45 e8             	add    -0x18(%ebp),%eax
 80484d2:	8b 00                	mov    (%eax),%eax
 80484d4:	83 45 f8 10          	addl   $0x10,-0x8(%ebp)
 80484d8:	81 7d f8 ff ff c7 00 	cmpl   $0xc7ffff,-0x8(%ebp)
 80484df:	7e c6                	jle    80484a7 <main+0x53>
 80484e1:	eb bb                	jmp    804849e <main+0x4a>
 80484e3:	90                   	nop    
 80484e4:	90                   	nop    
 80484e5:	90                   	nop    
 80484e6:	90                   	nop    
 80484e7:	90                   	nop    
 80484e8:	90                   	nop    
 80484e9:	90                   	nop    
 80484ea:	90                   	nop    
 80484eb:	90                   	nop    
 80484ec:	90                   	nop    
 80484ed:	90                   	nop    
 80484ee:	90                   	nop    
 80484ef:	90                   	nop