The executable file will be called from an external program, that will communicate with it through stdin/out, so I haven't the option to use System.out/in! To be specific, I'm going to write a UCI (universal chess interface) for my chess engine.

To write to stdout in C++ one uses "cout >> ..." isn't it? To read from it "cin", but when do I know when new data is available? How to convert to a Java string?

For a C++/JNI expert this should be piece of cake to answer. Please post some code. Thanks!

Hi there,

I have to write a native executable, that first starts my java program and then continously transfers it all input recived from stdin and writes output from the Java program to stdout. Can anyone please show me how to do this (platform-independently) with VisualC++ or gcc?

Ideally there would be two methods in the Java code, one for writing a String and one to accept a String. I'm a complete Newbie in C/C++ and JNI. Are there any pitfalls?

Thanks a lot!

Oh, that was a lighning fast reply

No, unfortunately i can't (or at least it would be very messy) implement the stack with recursion.

Another question: generally what is faster, 2 accesses to arrays with length 64 or 1 access to an array with 4096 length? I suppose this depends on CPU caching... so it's platform dependant... a rule of thumb?

Have a nice day!

Lastly I tried an optimization in a frequently executed piece of code: 3 variables of small size needed to be saved in a sort of "stack array" of fixed size. In the first version each variable was stored and retrieved from an individual array.

After packing all info into one single array with shifting and oring (saving two array acceses), the code was significantly faster! Obviously array access is much more expensive than a few bit-ops...

But how expensive is it really? I would guess it takes at least two condition checks for the bounds and one multiplication to calculate the address. Does anyone know exactly?

Thanks, that will be optimal. Strange they added this functionality so late...

An other question comes to my mind. What about this new hyperthreading technology of intels P4 (I read of a 25% performance increase): will a multithreaded java application benefit from it? If that's true, I should use the parallel algorithm with two threads even on a single processor system, hmm... how to detect a hyperthreading processor?

In my application I need to find out how many processors the host system has, in order to start an appropriate numer of threads (in my case numberOfThreads = numberOfCPUs). Is there a standard means of achieving this in Java? If not, can anyone please give me a hint how to do this platform-independantly with JNI... (I never used native code, so please explain this in a fool-proof manner) Thanks a lot!

When a block of code is unreachable at compile time, will the compiler remove it? Example:

final boolean DO_THAT = false;

if (DO_THAT) {
 // code...
}

In my application I'm specially interested in the removal of the condition check, since the condition will always be true or false at compile time.

Thanks a lot for your help. So basically bitIndex2() seems to be the right thing to do - just not in the fastest variant. Originally I hoped that maybe someone would come up with a better algorithm, maybe exploiting some obscure bit fumbling.

Because my work is in the early stages I'll consider switching to C/C++ and later optimize with assembly. Could be quite fun and challenging - maybe I'll toast my CPU   I wonder how a C++ and then an asm version would compare in terms of cycles.

Can it be true, that Sun 1.2 is faster than the successor VMs? Strange...

Merry Christmas & Happy new Year
NativeOne

Hi everybody. I'm working on a chess program which makes frequent calls to a method, that finds the position of the first (and only) set bit in a long value. So for 1->0, 2->1, 4->2, 8->3, 16->4, ...

The straight-foward code is this:

 public static int bitIndex1(long x) {
   int r = 0;
   while ((x & (1L << r)) == 0)
     r++;
   return r;
 }

The enhanced version takes less time in the average case:

 public static int bitIndex2(long x) {
   int r = 0;
   if ((x & 0xFFFFFFFF00000000L) != 0) r += 32;
   if ((x & 0xFFFF0000FFFF0000L) != 0) r += 16;
   if ((x & 0xFF00FF00FF00FF00L) != 0) r += 8;
   if ((x & 0xF0F0F0F0F0F0F0F0L) != 0) r += 4;
   if ((x & 0xCCCCCCCCCCCCCCCCL) != 0) r += 2;
   if ((x & 0xAAAAAAAAAAAAAAAAL) != 0) r++;
   return r;
 }

Is it possible to do this even faster? On x86 there is a single assembly instruction which does this kind of stuff