#ifdef _ARM_ARCH_7
#include 
float32x4_t scale( float32x4_t v, float f )
{
  return vmulq_n_f32( v, f );
}
#endif

Given that, among the iPhone OS devices, only the iPhone 3GS and the third-gen iPod Touch featured NEON up until recently, it typically wasn’t worth the effort to work on a NEON optimization since it would benefit only these devices, unless the application could require running on one of them (e.g. because its purpose is to processes videos recorded by the iPhone 3GS). However, with the arrival of the iPad it makes much more sense to develop NEON optimizations. In this post I’ll try to give you a primer on NEON.

Before we begin, a bit of setup

Do You Need It?

Detection and Selection

This way is to build the application for both ARMv6 and ARMv7 (Optimized setting in Xcode), and, using #ifdefs, disable at compile time the undesired code (the NEON code when building for ARMv6, the non-NEON fallback when building for ARMv7; __ARM_NEON__ will be defined if NEON is available); if you target only ARMv7 devices, then only build for ARMv7 (in that case, don’t forget to add armv7 in the UIRequiredDeviceCapabilities of your Info.plist). When your application is run, the device will automatically pick the most capable half it can: the ARMv7/NEON one for ARMv7-capable devices, the ARMv6 half, if present, otherwise. The drawback is that, unless you target only ARMv7 devices, the whole application code size (not just the code for which there is a NEON version) will end up twice in the final distribution: once compiled for ARMv6, and once for ARMv7. As executable code is typically a small portion of the application size, this is not a problem for most applications, but it is a problem for some of them.¹

Development

Architecture Overview

Programmer Model

Architectural features

Syntax

Instruction Overview

Load and Stores

Permutation

Comparisons and Boolean operators

Floating-Point

• just like AltiVec, only single-precision floating-point numbers are available
• by default, denormals are flushed to 0 and results are rounded to nearest
• only estimates to reciprocal square root and reciprocal are given, refinement steps are necessary to get the IEEE correct result
• there are single-instruction multiply-add and multiply-substract

• contrary to AltiVec, multiply-add seems to be UNfused, there is apparently an intermediate rounding step
• probably related to the previous point, refinement step instructions for reciprocal square root and reciprocal are provided.
• denormal handling cannot be turned on
• conversion to integer necessarily rounds towards 0
• there are no log and 2^x estimates
• some horizontal NEON operations are available, as well as absolute differences.

Integer

Miscellaneous

Cortex A8 implementation of NEON

The Cortex A8 implements NEON and VFP as a coprocessor “located” downstream from the ARM core: that is, NEON and VFP instructions go through the ARM pipeline undisturbed, before being decoded again by the NEON unit and going through its pipeline. This has a few consequences, the main one being that, while moving a value from an ARM register to a NEON/VFP register is fast, moving a value from a NEON/VFP register to an ARM register is very slow, causing a 20 cycle pipeline stall.

The Cortex A8 has a second NEON pipeline for load/store and permute instructions, so these instructions can be issued in parallel with non-permute instructions (provided there is no dependency issue). Remember the Cortex A8 (and its NEON unit) is an in-order core, so it is not going to go fetch farther instructions in the instruction stream to extract parallelism: only instructions next to each other can be issued in parallel. Notice that duplicating a scalar is considered a permute instruction, so provided you do so a bit before the result is needed, the operation is pretty much free.

Oh, you mean I have to conclude?

 
import time

if __name__ == "__main__":
    
    tm = time.clock()
    for i in range(0,9000000):
      result = 600 / 25 - 25 / 25
    tm = time.clock() - tm
    print("The result of son is %d, Cost time %fs" % (result,tm) )

    tm = time.clock()
    for i in range(0,9000000):
      result = 500 / 25 + 75 / 25
    tm = time.clock() - tm
    print("The result of teacher is %d, Cost time %fs" % (result,tm) )