[...]JDK 6 Rules! New Components in JTabbedPane are awesome. Use it! | javajiggle.com[...]…

A simple test for 10 million repetions shows x * x is 20 – 25 times faster than Math.pow(x, 2.0). Calling x*x in a method made only marginal difference.

Test code is below. The purpose of the “if (r > 200.0) f1 = f2;” statement is to ensure the compile is not optimising the code by inserting the same result for repeated calls to a function with the same parameter values. It made almost no difference to the run times.

Date date;
long startTime; // in milliseconds
long endTime;
double f1 = 15.69;
double f2 = 17.01;
double r = 0;
int cycles = 10000000;

date = new Date();
startTime = date.getTime();
for (int i = 0; i 200.0) f1 = f2;
}
date = new Date();
endTime = date.getTime();
System.out.println(“f * f runtime for “+cycles+” cycles: ” + ((endTime – startTime)) + ” milliseconds\r”);

date = new Date();
startTime = date.getTime();
for (int i = 0; i 200.0) f1 = f2;
}
date = new Date();
endTime = date.getTime();
System.out.println(“square(f) runtime for “+cycles+” cycles: ” + ((endTime – startTime)) + ” milliseconds\r”);

date = new Date();
startTime = date.getTime();
double two = 2.0;
for (int i = 0; i 200.0) f1 = f2;
}
date = new Date();
endTime = date.getTime();
System.out.println(” Math.pow(f1, two) runtime for “+cycles+” cycles: ” + ((endTime – startTime)) + ” milliseconds\r”);

what is the use of CheckJni flag?. If we dont set it in our code, then native singals still collide with JVM signals?

2. how does signal chaining help for handling native code related issues which can raise signal ?
>If the native code uses signals and creates the JVM, the JVM will override the signal handler in the native code. The signal chaining allows JVM to determine whether a raised signal was intended for it.

I believe that in native code, if two or more libraries use the same signals it is possible that at least one of the signal handlers will be overridden. Thus signal chaining can be used to ensure that the signals are properly dispatched to the right handlers. If I’m correct, it can be done by first loading a library that will store signal handlers when libraries register their signal handlers. It will then dispatch signals to the right signals handlers. This means that the dispatching library must be loaded first, before libraries that implement signal handlers are loaded.

Here is an example (jsig.c) implementation.
http://xref.jsecurity.net/openjdk-6/langtools/d3/dae/solaris_2vm_2jsig_8c-source.html

3. can we have more insight on 3rd approach of using LD_PRELOAD?
>LD_PRELOAD simply specifies libraries that must be loaded before other libraries are loaded. This avoids a need to link with the library that stores and dispatches to the signal handlers.

Signal example:
———————————————–
#include
#include
#include

void handler( int sig ){
printf(“signal handler invoked, signal: %d \n”, sig );
}

int main(){
signal( SIGINT, handler );
printf(“test SIGINT\n”);
while( 1 ){
sleep(1000);
}
return 1;
}