我试图在

java上实现

Fast Inverse Square Root,以加速向量规范化.然而,当我在Java中实现单精度版本时,我首先得到与1F /(float)Math.sqrt()相同的速度,然后快速下降到一半的速度.这是有趣的,因为当Math.sqrt使用(我推测)一个本地方法时,这涉及浮点除法,我听说的很慢.我的代码用于计算数字如下：

public static float fastInverseSquareRoot(float x){

float xHalf = 0.5F * x;

int temp = Float.floatToRawIntBits(x);

temp = 0x5F3759DF - (temp >> 1);

float newX = Float.intBitsToFloat(temp);

newX = newX * (1.5F - xHalf * newX * newX);

return newX;

}

使用我编写的一个简短的程序来迭代每1600万次,然后聚合结果,并重复,我得到如下结果：

1F / Math.sqrt() took 65209490 nanoseconds.

Fast Inverse Square Root took 65456128 nanoseconds.

Fast Inverse Square Root was 0.378224 percent slower than 1F / Math.sqrt()

1F / Math.sqrt() took 64131293 nanoseconds.

Fast Inverse Square Root took 26214534 nanoseconds.

Fast Inverse Square Root was 59.123647 percent faster than 1F / Math.sqrt()

1F / Math.sqrt() took 27312205 nanoseconds.

Fast Inverse Square Root took 56234714 nanoseconds.

Fast Inverse Square Root was 105.895914 percent slower than 1F / Math.sqrt()

1F / Math.sqrt() took 26493281 nanoseconds.

Fast Inverse Square Root took 56004783 nanoseconds.

Fast Inverse Square Root was 111.392402 percent slower than 1F / Math.sqrt()

我一直得到两者的速度大致相同的数字,随后是一个迭代,其中快速逆平方根保存了1F / Math.sqrt()所需的大约60％的时间,然后是几次迭代,大约是两次快速反向平方根作为控件运行.我很困惑为什么FISR会从Same – >快60％ – >每次运行我的程序都会慢100％.

编辑：以上数据是在eclipse中运行的.当我用javac / java运行程序时,我得到完全不同的数据：

1F / Math.sqrt() took 57870498 nanoseconds.

Fast Inverse Square Root took 88206794 nanoseconds.

Fast Inverse Square Root was 52.421004 percent slower than 1F / Math.sqrt()

1F / Math.sqrt() took 54982400 nanoseconds.

Fast Inverse Square Root took 83777562 nanoseconds.

Fast Inverse Square Root was 52.371599 percent slower than 1F / Math.sqrt()

1F / Math.sqrt() took 21115822 nanoseconds.

Fast Inverse Square Root took 76705152 nanoseconds.

Fast Inverse Square Root was 263.259133 percent slower than 1F / Math.sqrt()

1F / Math.sqrt() took 20159210 nanoseconds.

Fast Inverse Square Root took 80745616 nanoseconds.

Fast Inverse Square Root was 300.539585 percent slower than 1F / Math.sqrt()

1F / Math.sqrt() took 21814675 nanoseconds.

Fast Inverse Square Root took 85261648 nanoseconds.

Fast Inverse Square Root was 290.845374 percent slower than 1F / Math.sqrt()

编辑2：经过几次回应,好像几次迭代后速度稳定下来,但稳定的数字是非常不稳定的.任何人都知道为什么？

这是我的代码(不完全简洁,但这里是整个事情)：

public class FastInverseSquareRootTest {

public static FastInverseSquareRootTest conductTest() {

float result = 0F;

long startTime, endTime, midTime;

startTime = System.nanoTime();

for (float x = 1F; x < 4_000_000F; x += 0.25F) {

result = 1F / (float) Math.sqrt(x);

}

midTime = System.nanoTime();

for (float x = 1F; x < 4_000_000F; x += 0.25F) {

result = fastInverseSquareRoot(x);

}

endTime = System.nanoTime();

return new FastInverseSquareRootTest(midTime - startTime, endTime

- midTime);

}

public static float fastInverseSquareRoot(float x) {

float xHalf = 0.5F * x;

int temp = Float.floatToRawIntBits(x);

temp = 0x5F3759DF - (temp >> 1);

float newX = Float.intBitsToFloat(temp);

newX = newX * (1.5F - xHalf * newX * newX);

return newX;

}

public static void main(String[] args) throws Exception {

for (int i = 0; i < 7; i++) {

System.out.println(conductTest().toString());

}

}

private long controlDiff;

private long experimentalDiff;

private double percentError;

public FastInverseSquareRootTest(long controlDiff, long experimentalDiff) {

this.experimentalDiff = experimentalDiff;

this.controlDiff = controlDiff;

this.percentError = 100D * (experimentalDiff - controlDiff)

/ controlDiff;

}

@Override

public String toString() {

StringBuilder sb = new StringBuilder();

sb.append(String.format("1F / Math.sqrt() took %d nanoseconds.%n",

controlDiff));

sb.append(String.format(

"Fast Inverse Square Root took %d nanoseconds.%n",

experimentalDiff));

sb.append(String

.format("Fast Inverse Square Root was %f percent %s than 1F / Math.sqrt()%n",

Math.abs(percentError), percentError > 0D ? "slower"

: "faster"));

return sb.toString();

}

}