The iPhone has a surprisingly powerful engine under that shiny hood when it comes to floating-point computations. This is something that surprises a lot of programmers because by default, things can slow down a lot whenever any floating point numbers are involved. This session will explain the secrets to unlocking maximum performance for floating point calculations, from the mysteries of Thumb mode, to harnessing the full power of the forgotten vector floating point unit. Stay away from this session if he thought of reading or even (gasp!) writing assembly code scares you.

1. Cranking Floating Point
Performance Up To 11
Noel Llopis
Snappy Touch
http://twitter.com/snappytouch
noel@snappytouch.com
http://gamesfromwithin.com

7. Floating Point
Performance

8. Floating point numbers

9. Floating point numbers
• Representation of rational numbers

10. Floating point numbers
• Representation of rational numbers
• 1.2345, -0.8374, 2.0000, 14388439.34, etc

11. Floating point numbers
• Representation of rational numbers
• 1.2345, -0.8374, 2.0000, 14388439.34, etc
• Following IEEE 754 format

12. Floating point numbers
• Representation of rational numbers
• 1.2345, -0.8374, 2.0000, 14388439.34, etc
• Following IEEE 754 format
• Single precision: 32 bits

13. Floating point numbers
• Representation of rational numbers
• 1.2345, -0.8374, 2.0000, 14388439.34, etc
• Following IEEE 754 format
• Single precision: 32 bits
• Double precision: 64 bits

14. Floating point numbers

15. Floating point numbers

16. Why floating point
performance?

17. Why floating point
performance?
• Most games use floating point numbers for
most of their calculations

18. Why floating point
performance?
• Most games use floating point numbers for
most of their calculations
• Positions, velocities, physics, etc, etc.

19. Why floating point
performance?
• Most games use floating point numbers for
most of their calculations
• Positions, velocities, physics, etc, etc.
• Maybe not so much for regular apps

20. CPU

21. CPU
• 32-bit RISC ARM 11

22. CPU
• 32-bit RISC ARM 11
• 400-535Mhz

23. CPU
• 32-bit RISC ARM 11
• 400-535Mhz
• iPhone 2G/3G and iPod
Touch 1st and 2nd gen

24. CPU (iPhone 3GS)

25. CPU (iPhone 3GS)
• Cortex-A8 600MHz

26. CPU (iPhone 3GS)
• Cortex-A8 600MHz
• More advanced
architecture

27. CPU

28. CPU
• No floating point support
in the ARM CPU!!!

29. How about integer
math?

30. How about integer
math?
• No need to do any floating point
operations

31. How about integer
math?
• No need to do any floating point
operations
• Fully supported in the ARM processor

32. How about integer
math?
• No need to do any floating point
operations
• Fully supported in the ARM processor
• But...

33. Integer Divide

34. Integer Divide

35. Integer Divide
There is no integer divide

36. Fixed-point arithmetic

37. Fixed-point arithmetic
• Sometimes integer arithmetic doesn’t cut it

38. Fixed-point arithmetic
• Sometimes integer arithmetic doesn’t cut it
• You need to represent rational numbers

39. Fixed-point arithmetic
• Sometimes integer arithmetic doesn’t cut it
• You need to represent rational numbers
• Can use a fixed-point library.

40. Fixed-point arithmetic
• Sometimes integer arithmetic doesn’t cut it
• You need to represent rational numbers
• Can use a fixed-point library.
• Performs rational arithmetic with integer
values at a reduced range/resolution.

41. Fixed-point arithmetic
• Sometimes integer arithmetic doesn’t cut it
• You need to represent rational numbers
• Can use a fixed-point library.
• Performs rational arithmetic with integer
values at a reduced range/resolution.
• Not so great...

42. Floating point support

43. Floating point support
• There’s a floating point unit

44. Floating point support
• There’s a floating point unit
• Compiled C/C++/ObjC
code uses the VFP unit for
any floating point
operations.

45. Sample program

46. Sample program
struct Particle
{
float x, y, z;
float vx, vy, vz;
};

47. Sample program
struct Particle for (int i=0; i<MaxParticles; ++i)
{ {
float x, y, z; Particle& p = s_particles[i];
float vx, vy, vz; p.x += p.vx*dt;
}; p.y += p.vy*dt;
p.z += p.vz*dt;
p.vx *= drag;
p.vy *= drag;
p.vz *= drag;
}

48. Sample program
struct Particle for (int i=0; i<MaxParticles; ++i)
{ {
float x, y, z; Particle& p = s_particles[i];
float vx, vy, vz; p.x += p.vx*dt;
}; p.y += p.vy*dt;
p.z += p.vz*dt;
p.vx *= drag;
p.vy *= drag;
p.vz *= drag;
}
• 7.2 seconds on an iPod Touch 2nd gen

49. Floating point support

50. Floating point support
Trust no one!

51. Floating point support
Trust no one!
When in doubt, check the
assembly generated

52. Floating point support

53. Thumb Mode

54. Thumb Mode

55. Thumb Mode
• CPU has a special thumb
mode.

56. Thumb Mode
• CPU has a special thumb
mode.
• Less memory, maybe better
performance.

57. Thumb Mode
• CPU has a special thumb
mode.
• Less memory, maybe better
performance.
• No floating point support.

58. Thumb Mode
• CPU has a special thumb
mode.
• Less memory, maybe better
performance.
• No floating point support.
• Every time there’s an fp
operation, it switches out of
Thumb, does the fp operation,
and switches back on.

59. Thumb Mode

60. Thumb Mode
• It’s on by default!

61. Thumb Mode
• It’s on by default!
• Potentiallyoff. wins
turning it
HUGE

62. Thumb Mode
• It’s on by default!
• Potentiallyoff. wins
turning it
HUGE

63. Thumb Mode

64. Thumb Mode
• Turning off Thumb mode increased
performance in Flower Garden by over 2x

65. Thumb Mode
• Turning off Thumb mode increased
performance in Flower Garden by over 2x
• Heavy usage of floating point operations
though

66. Thumb Mode
• Turning off Thumb mode increased
performance in Flower Garden by over 2x
• Heavy usage of floating point operations
though
• Most games will probably benefit from
turning it off (especially 3D games)

68. 2.6 seconds!

69. ARM assembly
DISCLAIMER:

70. ARM assembly
DISCLAIMER:
I’m not an ARM assembly expert!!!

71. ARM assembly
DISCLAIMER:
I’m not an ARM assembly expert!!!

72. ARM assembly
DISCLAIMER:
I’m not an ARM assembly expert!!!

73. ARM assembly
DISCLAIMER:
I’m not an ARM assembly expert!!!
Z80!!!

74. ARM assembly

75. ARM assembly
• Hit the docs

76. ARM assembly
• Hit the docs
• References included in your USB card

77. ARM assembly
• Hit the docs
• References included in your USB card
• Or download them from the ARM site

78. ARM assembly
• Hit the docs
• References included in your USB card
• Or download them from the ARM site
• http://bit.ly/arminfo

79. ARM assembly

80. ARM assembly
• Reading assembly is a very important skill
for high-performance programming

81. ARM assembly
• Reading assembly is a very important skill
for high-performance programming
• Writing is more specialized. Most people
don’t need to.

82. VFP unit

83. VFP unit
A0

84. VFP unit
A0
+

85. VFP unit
A0
+
B0

86. VFP unit
A0
+
B0
=

87. VFP unit
A0
+
B0
=
C0

88. VFP unit
A0
+
B0
=
C0
A1
+
B1
=
C1

89. VFP unit
A0 A2
+ +
B0 B2
= =
C0 C2
A1
+
B1
=
C1

90. VFP unit
A0 A2
+ +
B0 B2
= =
C0 C2
A1 A3
+ +
B1 B3
= =
C1 C3

91. VFP unit

92. VFP unit
A0 A1 A2 A3

93. VFP unit
A0 A1 A2 A3
+

94. VFP unit
A0 A1 A2 A3
+
B0 B1 B2 B3

95. VFP unit
A0 A1 A2 A3
+
B0 B1 B2 B3
=

96. VFP unit
A0 A1 A2 A3
+
B0 B1 B2 B3
=
C0 C1 C2 C3

97. VFP unit
A0 A1 A2 A3
+
B0 B1 B2 B3
=
C0 C1 C2 C3
Sweet! How do we
use the vfp?

98. Like this!
"fldmias %2, {s8-s23} nt"
"fldmias %1!, {s0-s3} nt"
"fmuls s24, s8, s0 nt"
"fmacs s24, s12, s1 nt"
"fldmias %1!, {s4-s7} nt"
"fmacs s24, s16, s2 nt"
"fmacs s24, s20, s3 nt"
"fstmias %0!, {s24-s27} nt"

99. Writing vfp assembly

100. Writing vfp assembly
• There are two parts to it

101. Writing vfp assembly
• There are two parts to it
• How to write any assembly in gcc

102. Writing vfp assembly
• There are two parts to it
• How to write any assembly in gcc
• Learning ARM and VPM assembly

103. vfpmath library

104. vfpmath library
• Already done a lot of work for you

105. vfpmath library
• Already done a lot of work for you
• http://code.google.com/p/vfpmathlibrary

106. vfpmath library
• Already done a lot of work for you
• http://code.google.com/p/vfpmathlibrary
• Vector/matrix math

107. vfpmath library
• Already done a lot of work for you
• http://code.google.com/p/vfpmathlibrary
• Vector/matrix math
• Might not be exactly what you need, but it’s
a great starting point

108. Assembly in gcc
• Only use it when targeting the device

109. Assembly in gcc
• Only use it when targeting the device
#include <TargetConditionals.h>
#if (TARGET_IPHONE_SIMULATOR == 0) && (TARGET_OS_IPHONE == 1)
#define USE_VFP
#endif

110. Assembly in gcc
• The basics
asm (“cmp r2, r1”);

111. Assembly in gcc
• The basics
asm (“cmp r2, r1”);
http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-
HOWTO.html

112. Assembly in gcc
• Multiple lines
asm (
“mov r0, #1000nt”
“cmp r2, r1nt”
);

113. Assembly in gcc
• Accessing C variables
asm (//assembly code
: // output operands
: // input operands
: // clobbered registers
);

114. Assembly in gcc
• Accessing C variables
asm (//assembly code
: // output operands
: // input operands
: // clobbered registers
);
int src = 19;
int dest = 0;
asm volatile (
"add %0, %1, #42"
: "=r" (dest)
: "r" (src)
:
);

115. Assembly in gcc
• Accessing C variables
asm (//assembly code
: // output operands
: // input operands
: // clobbered registers
);
int src = 19;
int dest = 0;
%0, %1, etc are the
variables in order
asm volatile (
"add %0, %1, #42"
: "=r" (dest)
: "r" (src)
:
);

116. Assembly in gcc

117. Assembly in gcc
int src = 19;
int dest = 0;
asm volatile (
"add r10, %1, #42nt"
"add %0, r10, #33nt"
: "=r" (dest)
: "r" (src)
: "r10"
);

118. Assembly in gcc
int src = 19;
int dest = 0;
asm volatile (
"add r10, %1, #42nt"
"add %0, r10, #33nt"
: "=r" (dest)
: "r" (src)
: "r10"
);
Clobber register list
are registers used by
the asm block

119. Assembly in gcc
int src = 19; volatile prevents “optimizations”
int dest = 0;
asm volatile (
"add r10, %1, #42nt"
"add %0, r10, #33nt"
: "=r" (dest)
: "r" (src)
: "r10"
);
Clobber register list
are registers used by
the asm block

120. VFP asm
Four banks of 8 32-bit registers each

121. VFP asm
Four banks of 8 32-bit registers each
#define VFP_VECTOR_LENGTH(VEC_LENGTH)
"fmrx r0, fpscr nt"
"bic r0, r0, #0x00370000 nt"
"orr r0, r0, #0x000" #VEC_LENGTH "0000 nt"
"fmxr fpscr, r0 nt"

122. VFP asm

123. VFP asm

124. VFP asm
for (int i=0; i<MaxParticles; ++i)
{
Particle& p = s_particles[i];
p.x += p.vx*dt;
p.y += p.vy*dt;
p.z += p.vz*dt;
p.vx *= drag;
p.vy *= drag;
p.vz *= drag;
}

125. VFP asm
for (int i=0; i<MaxParticles; ++i) for (int i=0; i<MaxParticles; ++i)
{ {
Particle& p = s_particles[i];
Particle* p = &s_particles[i];
p.x += p.vx*dt;
p.y += p.vy*dt; asm volatile (
p.z += p.vz*dt; "fldmias %0, {s0-s5} nt"
p.vx *= drag;
"fldmias %1, {s6-s8} nt"
p.vy *= drag;
p.vz *= drag; "fldmias %2, {s9-s11} nt"
} "fmacs s0, s3, s6 nt"
"fmuls s3, s3, s9 nt"
"fstmias %0, {s0-s5} nt"
: "=r" (p)
: "r" (p), "r" (dtArray),
"r" (dragArray)
:
);
}

126. VFP asm
for (int i=0; i<MaxParticles; ++i) for (int i=0; i<MaxParticles; ++i)
{ {
Particle& p = s_particles[i];
Particle* p = &s_particles[i];
p.x += p.vx*dt;
p.y += p.vy*dt; asm volatile (
p.z += p.vz*dt; "fldmias %0, {s0-s5} nt"
p.vx *= drag;
"fldmias %1, {s6-s8} nt"
p.vy *= drag;
p.vz *= drag; "fldmias %2, {s9-s11} nt"
} "fmacs s0, s3, s6 nt"
"fmuls s3, s3, s9 nt"
Was: 2.6 seconds
"fstmias %0, {s0-s5}
: "=r" (p)
nt"
: "r" (p), "r" (dtArray),
"r" (dragArray)
:
);
}

127. VFP asm
for (int i=0; i<MaxParticles; ++i) for (int i=0; i<MaxParticles; ++i)
{ {
Particle& p = s_particles[i];
Particle* p = &s_particles[i];
p.x += p.vx*dt;
p.y += p.vy*dt; asm volatile (
p.z += p.vz*dt; "fldmias %0, {s0-s5} nt"
p.vx *= drag;
"fldmias %1, {s6-s8} nt"
p.vy *= drag;
p.vz *= drag; "fldmias %2, {s9-s11} nt"
} "fmacs s0, s3, s6 nt"
"fmuls s3, s3, s9 nt"
Was: 2.6 seconds
"fstmias %0, {s0-s5}
: "=r" (p)
nt"
: "r" (p), "r" (dtArray),
Now: 1.4 seconds!! "r" (dragArray)
:
);
}

128. VFP asm
Let’s do 6 operations at once!
struct Particle2
{
float x0, y0, z0;
float x1, y1, z1;
float vx0, vy0, vz0;
float vx1, vy1, vz1;
};

129. VFP asm
for (int i=0; i<iterations; ++i)
{
Particle2* p = &s_particles2[i];
asm volatile (
"fldmias %0, {s0-s11} nt"
"fldmias %1, {s12-s17} nt"
"fldmias %2, {s18-s23} nt"
"fmacs s0, s6, s12 nt"
"fmuls s6, s6, s18 nt"
"fstmias %0, {s0-s11} nt"
: "=r" (p)
: "r" (p), "r" (dtArray), "r" (dragArray)
:
);
}

130. VFP asm
for (int i=0; i<iterations; ++i)
{
Particle2* p = &s_particles2[i];
asm volatile (
"fldmias %0, {s0-s11} nt"
"fldmias %1, {s12-s17} nt"
"fldmias %2, {s18-s23} nt"
"fmacs s0, s6, s12 nt"
"fmuls s6, s6, s18 nt"
"fstmias %0, {s0-s11} nt"
: "=r" (p)
: "r" (p), "r" (dtArray), "r" (dragArray)
:
);
} Was: 1.4 seconds

131. VFP asm
for (int i=0; i<iterations; ++i)
{
Particle2* p = &s_particles2[i];
asm volatile (
"fldmias %0, {s0-s11} nt"
"fldmias %1, {s12-s17} nt"
"fldmias %2, {s18-s23} nt"
"fmacs s0, s6, s12 nt"
"fmuls s6, s6, s18 nt"
"fstmias %0, {s0-s11} nt"
: "=r" (p)
: "r" (p), "r" (dtArray), "r" (dragArray)
:
);
} Was: 1.4 seconds
Now: 1.2 seconds

132. VFP asm
What’s the loop/cache overhead?
for (int i=0; i<MaxParticles; ++i)
{
Particle* p = &s_particles[i];
p->x = p->vx;
p->y = p->vy;
p->z = p->vz;
}

133. VFP asm
What’s the loop/cache overhead?
for (int i=0; i<MaxParticles; ++i)
{
Particle* p = &s_particles[i];
p->x = p->vx;
p->y = p->vy;
p->z = p->vz;
}
Was: 1.2 seconds

134. VFP asm
What’s the loop/cache overhead?
for (int i=0; i<MaxParticles; ++i)
{
Particle* p = &s_particles[i];
p->x = p->vx;
p->y = p->vy;
p->z = p->vz;
}
Was: 1.2 seconds
Now: 1.2 seconds!!!!

136. Matrix multiply

137. Matrix multiply
Straight from vfpmathlib

138. Matrix multiply
Straight from vfpmathlib
Touch: 0.037919 s

139. Matrix multiply
Straight from vfpmathlib
Touch: 0.037919 s
Normal: 0.096855 s

140. Matrix multiply
Straight from vfpmathlib
Touch: 0.037919 s
Normal: 0.096855 s
VFP: 0.042216 s

141. Matrix multiply
Straight from vfpmathlib
Touch: 0.037919 s
Normal: 0.096855 s
VFP: 0.042216 s
About 2x faster!

142. Good use of vfp

143. Good use of vfp
• Matrix operations

144. Good use of vfp
• Matrix operations
• Particle systems

145. Good use of vfp
• Matrix operations
• Particle systems
• Skinning

146. Good use of vfp
• Matrix operations
• Particle systems
• Skinning
• Physics

147. Good use of vfp
• Matrix operations
• Particle systems
• Skinning
• Physics
• Procedural content generation

148. Good use of vfp
• Matrix operations
• Particle systems
• Skinning
• Physics
• Procedural content generation
• ....

149. What about the 3GS?

150. What about the 3GS?
3G 3GS
Thumb 7.2 8.0
Normal 2.6 2.6
VFP1 1.4 1.30
VFP2 1.2 0.64
Touch 1.2 0.18

151. What about the 3GS?
3G 3GS
Thumb 7.2 8.0
Normal 2.6 2.6
VFP1 1.4 1.30
VFP2 1.2 0.64
Touch 1.2 0.18

152. What about the 3GS?
3G 3GS
Thumb 7.2 8.0
Normal 2.6 2.6
VFP1 1.4 1.30
VFP2 1.2 0.64
Touch 1.2 0.18

153. What about the 3GS?
3G 3GS
Thumb 7.2 8.0
Normal 2.6 2.6
VFP1 1.4 1.30
VFP2 1.2 0.64
Touch 1.2 0.18

154. What about the 3GS?
3G 3GS
Thumb 7.2 8.0
Normal 2.6 2.6
VFP1 1.4 1.30
VFP2 1.2 0.64
Touch 1.2 0.18

155. What about the 3GS?
3G 3GS
Thumb 7.2 8.0
Normal 2.6 2.6
VFP1 1.4 1.30
VFP2 1.2 0.64
Touch 1.2 0.18

156. What about the 3GS?
3G 3GS
Thumb 7.2 8.0
Normal 2.6 2.6
VFP1 1.4 1.30
VFP2 1.2 0.64
Touch 1.2 0.18

157. More 3GS: NEON

158. More 3GS: NEON
• SIMD coprocessor

159. More 3GS: NEON
• SIMD coprocessor
• Floating point and integer

160. More 3GS: NEON
• SIMD coprocessor
• Floating point and integer
• Huge potential

161. More 3GS: NEON
• SIMD coprocessor
• Floating point and integer
• Huge potential
• Very little documentation right now :-(

162. Thank you!
Noel Llopis
Snappy Touch
http://twitter.com/snappytouch
noel@snappytouch.com
http://gamesfromwithin.com