几秒钟后，一种方法需要更长的时间才能执行

Question

I have this method:

public double sineWave(double t) 
{
   return amplitude==0?0:Math.sin(t * frequency * Math.PI*2 + phase) * amplitude;
}

It is called by another method in another class to generate a sample of a simple sine wave, which is then added in a buffer to send to the sound card. t is the time. For some reason, the more the application calls this method, the slower it gets. It just makes no sense, after 15 seconds it's slow enough to use a full core of my CPU and make the audio stutter.

I'm 100% sure it's this piece of code, because if I replace it with a return 0, the time it takes to run it (measured with System.nanotime() ) is constant.

Why is this happening? Is there something I can do to fix this?

Answer 1

From the information here - while it is not clear how big your buffer is, you are incrementing t with each iteration. Assuming your frequency is quite high, you are increasing the Sin() argument with each iteration. Have checks to see if the argument is constantly increasing to a very high value. A quick and dirty test shows that Sin performance goes down -

public class SinTest {
  public static void main(String args[]) {
    long angle = Long.parseLong(args[0]);
    long startTime = System.nanoTime();
    for(long l=0L; l<=1000000L; l++) {
      Math.sin(angle);
    }
    long estimatedTime = System.nanoTime() - startTime;
    System.out.println(estimatedTime);
  }
}

$ java SinTest 100000
29181000
$ java SinTest 10000000
138598000

Answer 2

Please give no points, so the solution would be given the answer of @mk:

public double sineWave(double t) 
{
    final double TAU = Math.PI *2;
    double a = t * frequency;
    a -= (long)a;
    return amplitude==0?0:Math.sin(a * TAU + phase) * amplitude;
}

Answer 3

i solved the problem with a lookup table:

private static final int LUT_SIZE=1000000;
private static double[] sineLookupTable=new double[(int)(Math.PI*2*LUT_SIZE)];
static{
    for(double i=0;i<sineLookupTable.length;i++){
        sineLookupTable[(int)i]=Math.sin(i/(double)LUT_SIZE);
    }

}
private static double sinLUT(double t){
    return sineLookupTable[(int) (((long) Math.floor((t%Math.PI*2)*LUT_SIZE))%sineLookupTable.length)];
}
public double sineWave(double t) {
    return amplitude==0?0:sinLUT(t * frequency * Math.PI*2 + phase) * amplitude;
}

it works... kinda, only problem is that i get a lot of distorsion on high frequencies. is there some interpolation method you can suggest?

Answer 4

Current versions of the Java framework will attempt to mod-reduce the argument to Math.sin using a mathematically-perfect value of 2π, rather than the value Math.PI*2 . For code such as yours, this means the code will take longer and yield less accurate results than if mod reduction had been performed using the same scale factor as was used in multiplication (ie Math.PI*2 ). To get good accuracy and speed, you should perform modulo reduction before doing the multiplication, using something like:

double thisSpin = t * frequency;
thisSpin -= (thisSpin - Math.Floor(thisSpin)) * 8.0; // value of 0-7.9999=one rotation
switch((int)(thisSpin*8.0))
{
  case 0: return  Math.sin(  thisSpin   * (Math.PI/4.0));
  case 1: return  Math.cos((2-thisSpin) * (Math.PI/4.0));
  case 2: return  Math.cos((thisSpin-2) * (Math.PI/4.0));
  case 3: return  Math.sin((4-thisSpin) * (Math.PI/4.0));
  case 4: return -Math.sin((thisSpin-4) * (Math.PI/4.0));
  case 5: return -Math.cos((6-thisSpin) * (Math.PI/4.0));
  case 6: return -Math.cos((thisSpin-6) * (Math.PI/4.0));
  case 7: return -Math.sin((8-thisSpin) * (Math.PI/4.0));
  default: return 0; // Shouldn't be possible, but thisSpin==8 would be congruent to 0
}

That will ensure that neither sin nor cos is ever used with an argument greater than π/4, which is according to the documentation the point where Java switches to using slow and counterproductive range reduction.