360iDev presentation

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

2. void* p = &s_particles2[0];
asm volatile (
"fldmias %1, {s0} nt"
"fldmias %2, {s1} nt"
"mov r1, %0 nt"
"mov r2, %0 nt"
"mov r3, %3 nt"
"0: nt"
"fldmias r1!, {s8-s13} nt"
"fldmias r1!, {s16-s21} nt"
"fmacs s8, s16, s0 nt"
"fmuls s16, s16, s1 nt"
"fstmias r2!, {s8-s13} nt"
"fstmias r2!, {s16-s21} nt"
"subs r3, r3, #1 nt"
"bne 0b nt"
:
: "r" (p), "r" (&dt), "r" (&drag), "r" (iterations)
: "r0", "r1", "r2", "r3", "cc", "memory"
);

10. “Don’t do that bit-
twiddling thing”

11. “Don’t do that bit-
twiddling thing”
“Optimize at the
algorithm level”

12. “Don’t do that bit-
twiddling thing”
“Optimize at the
algorithm level”
Yes, but key to good performance
is looking at your data and your
target platform

13. Floating Point
Performance

14. Floating point numbers

15. Floating point numbers
• Representation of rational numbers

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

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

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

19. 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

20. Floating point numbers

21. Floating point numbers

22. Why floating point
performance?

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

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

25. 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

26. CPU

27. CPU
• 32-bit RISC ARM 11

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

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

30. CPU (iPhone 3GS)

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

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

33. CPU

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

35. How about integer
math?

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

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

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

39. Integer Divide

40. Integer Divide

41. Integer Divide
There is no integer divide

42. Fixed-point arithmetic

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

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

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

46. 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.

47. 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...

48. Floating point support

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

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

51. Sample program

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

53. 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;
}

54. 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;
}
• 14.1 seconds on an iPod Touch 2nd gen

55. Floating point support

56. Floating point support
Trust no one!

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

58. Floating point support

59. Thumb Mode

60. Thumb Mode

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

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

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

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

65. Thumb Mode

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

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

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

69. Thumb Mode

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

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

72. 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)

74. 5.1 seconds!

75. ARM assembly
DISCLAIMER:

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

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

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

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

80. ARM assembly

81. ARM assembly
• Hit the docs

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

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

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

85. ARM assembly

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

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

88. VFP unit

89. VFP unit
A0

90. VFP unit
A0
+

91. VFP unit
A0
+
B0

92. VFP unit
A0
+
B0
=

93. VFP unit
A0
+
B0
=
C0

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

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

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

97. VFP unit

98. VFP unit
A0 A1 A2 A3

99. VFP unit
A0 A1 A2 A3
+

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

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

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

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

104. 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"

105. Writing vfp assembly

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

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

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

109. vfpmath library

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

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

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

113. 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

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

115. 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

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

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

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

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

120. 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)
:
);

121. 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)
:
);

122. Assembly in gcc

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

124. 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

125. 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

126. VFP asm
Four banks of 8 32-bit registers each
Can address them as single precision
or as doubles

127. VFP asm

128. VFP asm
#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"

129. VFP asm
Bank 0 is always scalar!
Operations only work on a single bank
(wrap around possible)

130. VFP asm

131. VFP asm

132. 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;
}

133. VFP asm
for (int i=0; i<MaxParticles; ++i)
for (int i=0; i<MaxParticles; ++i)
{
Particle& p = s_particles[i]; {
p.x += p.vx*dt; void* p = &s_particles[i];
p.y += p.vy*dt;
asm volatile (
p.z += p.vz*dt;
p.vx *= drag; "fldmias %1, {s0} nt"
p.vy *= drag; "fldmias %2, {s1} nt"
p.vz *= drag; "fldmias %0, {s8-s13} nt"
}
"fmacs s8, s11, s0 nt"
"fmuls s11, s11, s1 nt"
"fstmias %0, {s8-s13} nt"
:
: "r" (p), "r" (&dt), "r" (&drag)
: "r0", "cc", "memory"
);
}

134. VFP asm
for (int i=0; i<MaxParticles; ++i)
for (int i=0; i<MaxParticles; ++i)
{
Particle& p = s_particles[i]; {
p.x += p.vx*dt; void* p = &s_particles[i];
p.y += p.vy*dt;
asm volatile (
p.z += p.vz*dt;
p.vx *= drag; "fldmias %1, {s0} nt"
p.vy *= drag; "fldmias %2, {s1} nt"
p.vz *= drag; "fldmias %0, {s8-s13} nt"
}
"fmacs s8, s11, s0 nt"
"fmuls s11, s11, s1 nt"
Was: 5.1 seconds "fstmias %0, {s8-s13} nt"
:
: "r" (p), "r" (&dt), "r" (&drag)
: "r0", "cc", "memory"
);
}

135. VFP asm
for (int i=0; i<MaxParticles; ++i)
for (int i=0; i<MaxParticles; ++i)
{
Particle& p = s_particles[i]; {
p.x += p.vx*dt; void* p = &s_particles[i];
p.y += p.vy*dt;
asm volatile (
p.z += p.vz*dt;
p.vx *= drag; "fldmias %1, {s0} nt"
p.vy *= drag; "fldmias %2, {s1} nt"
p.vz *= drag; "fldmias %0, {s8-s13} nt"
}
"fmacs s8, s11, s0 nt"
"fmuls s11, s11, s1 nt"
Was: 5.1 seconds "fstmias %0, {s8-s13} nt"
:
Now: 2.7 seconds!! : "r" (p), "r" (&dt), "r" (&drag)
: "r0", "cc", "memory"
);
}

136. VFP asm
for (int i=0; i<MaxParticles; ++i)
{
void* p = &s_particles[i];
asm volatile (
"fldmias %1, {s0} nt"
"fldmias %2, {s1} nt"
"fldmias %0, {s8-s13} nt"
"fmacs s8, s11, s0 nt"
"fmuls s11, s11, s1 nt"
"fstmias %0, {s8-s13} nt"
:
: "r" (p), "r" (&dt), "r" (&drag)
: "r0", "cc", "memory"
);
}

137. VFP asm
for (int i=0; i<MaxParticles; ++i) Same every loop!
{
void* p = &s_particles[i];
asm volatile (
"fldmias %1, {s0} nt"
"fldmias %2, {s1} nt"
"fldmias %0, {s8-s13} nt"
"fmacs s8, s11, s0 nt"
"fmuls s11, s11, s1 nt"
"fstmias %0, {s8-s13} nt"
:
: "r" (p), "r" (&dt), "r" (&drag)
: "r0", "cc", "memory"
);
}

138. VFP asm
void* p = &s_particles[0];
asm volatile (
"fldmias %1, {s0} nt"
"fldmias %2, {s1} nt"
"mov r1, %0 nt"
"mov r2, %0 nt"
"mov r3, %3 nt"
"0: nt"
"fldmias r1!, {s8-s13} nt"
"fmacs s8, s11, s0 nt"
"fmuls s11, s11, s1 nt"
"fstmias r2!, {s8-s13} nt"
"subs r3, r3, #1 nt"
"bne 0b nt"
:
: "r" (p), "r" (&dt), "r" (&drag), "r" (MaxParticles)
: "r0", "r1", "r2", "r3", "cc", "memory"
);

139. VFP asm
void* p = &s_particles[0];
asm volatile (
"fldmias %1, {s0} nt" Was: 2.7 seconds
"fldmias %2, {s1} nt"
"mov r1, %0 nt"
"mov r2, %0 nt"
"mov r3, %3 nt"
"0: nt"
"fldmias r1!, {s8-s13} nt"
"fmacs s8, s11, s0 nt"
"fmuls s11, s11, s1 nt"
"fstmias r2!, {s8-s13} nt"
"subs r3, r3, #1 nt"
"bne 0b nt"
:
: "r" (p), "r" (&dt), "r" (&drag), "r" (MaxParticles)
: "r0", "r1", "r2", "r3", "cc", "memory"
);

140. VFP asm
void* p = &s_particles[0];
asm volatile (
"fldmias %1, {s0} nt" Was: 2.7 seconds
"fldmias %2, {s1} nt"
"mov r1, %0 nt" Now: 2.7 seconds
"mov r2, %0 nt"
"mov r3, %3 nt"
"0: nt"
"fldmias r1!, {s8-s13} nt"
"fmacs s8, s11, s0 nt"
"fmuls s11, s11, s1 nt"
"fstmias r2!, {s8-s13} nt"
"subs r3, r3, #1 nt"
"bne 0b nt"
:
: "r" (p), "r" (&dt), "r" (&drag), "r" (MaxParticles)
: "r0", "r1", "r2", "r3", "cc", "memory"
);

141. VFP asm
We can do 8 operations at once. So let’s try doing two
particles in a single operation.
struct Particle2
{
float x0, y0, z0;
float x1, y1, z1;
float vx0, vy0, vz0;
float vx1, vy1, vz1;
};

142. VFP asm
void* p = &s_particles2[0];
asm volatile (
"fldmias %1, {s0} nt"
"fldmias %2, {s1} nt"
"mov r1, %0 nt"
"mov r2, %0 nt"
"mov r3, %3 nt"
"0: nt"
"fldmias r1!, {s8-s13} nt"
"fldmias r1!, {s16-s21} nt"
"fmacs s8, s16, s0 nt"
"fmuls s16, s16, s1 nt"
"fstmias r2!, {s8-s13} nt"
"fstmias r2!, {s16-s21} nt"
"subs r3, r3, #1 nt"
"bne 0b nt"
:
: "r" (p), "r" (&dt), "r" (&drag), "r" (iterations)
: "r0", "r1", "r2", "r3", "cc", "memory"
);

143. VFP asm
void* p = &s_particles2[0];
asm volatile (
"fldmias %1, {s0}
"fldmias %2, {s1}
nt"
nt" Was: 2.77 seconds
"mov r1, %0 nt"
"mov r2, %0 nt"
"mov r3, %3 nt"
"0: nt"
"fldmias r1!, {s8-s13} nt"
"fldmias r1!, {s16-s21} nt"
"fmacs s8, s16, s0 nt"
"fmuls s16, s16, s1 nt"
"fstmias r2!, {s8-s13} nt"
"fstmias r2!, {s16-s21} nt"
"subs r3, r3, #1 nt"
"bne 0b nt"
:
: "r" (p), "r" (&dt), "r" (&drag), "r" (iterations)
: "r0", "r1", "r2", "r3", "cc", "memory"
);

144. VFP asm
void* p = &s_particles2[0];
asm volatile (
"fldmias %1, {s0}
"fldmias %2, {s1}
nt"
nt" Was: 2.77 seconds
"mov r1, %0 nt"
"mov r2, %0
"mov r3, %3
nt"
nt" Now: 2.67 seconds
"0: nt"
"fldmias r1!, {s8-s13} nt"
"fldmias r1!, {s16-s21} nt"
"fmacs s8, s16, s0 nt"
"fmuls s16, s16, s1 nt"
"fstmias r2!, {s8-s13} nt"
"fstmias r2!, {s16-s21} nt"
"subs r3, r3, #1 nt"
"bne 0b nt"
:
: "r" (p), "r" (&dt), "r" (&drag), "r" (iterations)
: "r0", "r1", "r2", "r3", "cc", "memory"
);

145. 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;
}

146. 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: 2.67 seconds

147. 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: 2.67 seconds
Now: 2.41 seconds!!!!

149. Matrix multiply

150. Matrix multiply
Straight from vfpmathlib

151. Matrix multiply
Straight from vfpmathlib
Touch: 0.0379 s

152. Matrix multiply
Straight from vfpmathlib
Touch: 0.0379 s
Normal: 0.0968 s

153. Matrix multiply
Straight from vfpmathlib
Touch: 0.0379 s
Normal: 0.0968 s
VFP: 0.0422 s

154. Matrix multiply
Straight from vfpmathlib
Touch: 0.0379 s
Normal: 0.0968 s
VFP: 0.0422 s
About 2x faster!

155. Good use of vfp

156. Good use of vfp
Something with lots of fp operations in a row

157. Good use of vfp
Something with lots of fp operations in a row
• Matrix operations

158. Good use of vfp
Something with lots of fp operations in a row
• Matrix operations
• Particle systems

159. Good use of vfp
Something with lots of fp operations in a row
• Matrix operations
• Particle systems
• Skinning

160. Good use of vfp
Something with lots of fp operations in a row
• Matrix operations
• Particle systems
• Skinning
• Physics

161. Good use of vfp
Something with lots of fp operations in a row
• Matrix operations
• Particle systems
• Skinning
• Physics
• Procedural content generation

162. Good use of vfp
Something with lots of fp operations in a row
• Matrix operations
• Particle systems
• Skinning
• Physics
• Procedural content generation
• ....

163. What about the 3GS?

164. What about the 3GS?
3G 3GS
Thumb 14.1 14.5
Normal 5.14 4.76
VFP1 2.77 4.53
VFP2 2.77 4.26
VFP3 2.66 3.57
Touch 2.41 0.42

165. What about the 3GS?
3G 3GS
Thumb 14.1 14.5
Normal 5.14 4.76
VFP1 2.77 4.53
VFP2 2.77 4.26
VFP3 2.66 3.57
Touch 2.41 0.42

166. What about the 3GS?
3G 3GS
Thumb 14.1 14.5
Normal 5.14 4.76
VFP1 2.77 4.53
VFP2 2.77 4.26
VFP3 2.66 3.57
Touch 2.41 0.42

167. What about the 3GS?
3G 3GS
Thumb 14.1 14.5
Normal 5.14 4.76
VFP1 2.77 4.53
VFP2 2.77 4.26
VFP3 2.66 3.57
Touch 2.41 0.42

168. Matrix multiply on 3GS
In ms

169. Matrix multiply on 3GS
In ms
3G 3GS
Normal 96 82
VFP1 42 90
VFP2 42 75
Touch 38 19

170. Matrix multiply on 3GS
In ms
3G 3GS
Normal 96 82
VFP1 42 90
VFP2 42 75
Touch 38 19

171. Matrix multiply on 3GS
In ms
3G 3GS
Normal 96 82
VFP1 42 90
VFP2 42 75
Touch 38 19

172. Matrix multiply on 3GS
In ms
3G 3GS
Normal 96 82
VFP1 42 90
VFP2 42 75
Touch 38 19

173. VFP resources
• ARM and VFP reference in your USB drive
• http://code.google.com/p/vfpmathlibrary
• http://aleiby.blogspot.com/2008/12/iphone-
vfp-for-n00bs.html
• http://www.ibiblio.org/gferg/ldp/GCC-
Inline-Assembly-HOWTO.html

174. More 3GS: NEON

175. More 3GS: NEON
• SIMD coprocessor

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

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

178. More 3GS: NEON
• SIMD coprocessor
• Floating point and integer
• Huge potential
• Not many examples yet

179. NEON resources

180. NEON resources
• Cortex A8 reference in USB drive

181. NEON resources
• Cortex A8 reference in USB drive
• http://gcc.gnu.org/onlinedocs/gcc/ARM-
NEON-Intrinsics.html

182. NEON resources
• Cortex A8 reference in USB drive
• http://gcc.gnu.org/onlinedocs/gcc/ARM-
NEON-Intrinsics.html
• http://code.google.com/p/oolongengine/
source/browse/trunk/Oolong+Engine2/
Math/neonmath

183. Conclusions

184. Conclusions
• Turn Thumb mode off NOW

185. Conclusions
• Turn Thumb mode off NOW
• Expect to get at least 2x performance in
older hardware by using vfp

186. Conclusions
• Turn Thumb mode off NOW
• Expect to get at least 2x performance in
older hardware by using vfp
• Not much difference in 3GS (but it’s fast
already)

187. Conclusions
• Turn Thumb mode off NOW
• Expect to get at least 2x performance in
older hardware by using vfp
• Not much difference in 3GS (but it’s fast
already)
• NEON SIMD tech still unused. Research
that and be the first one with the killer 3GS
app!

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