Hadi Java programım darboğaz gerçekten sıkı döngüler vektör nokta ürün grup hesaplamak için olduğunu söylüyorlar. Evet profilli gördüm, Evet darboğaz var, evet bu önemli, evet bu algoritma böyle olmalı, Evet Marathon bayt kodu, vb optimize etmek için koşuyoruz.

Bu iş, aslında, ürünleri nokta. Olduğu gibi, iki float[50] ve ikili ürünlerin toplamı hesaplamak gerekiyor. İşlemci komut setleri operasyonları bu tür hızlı bir şekilde gerçekleştirmek ve toplu olarak, SSE veya BÖYLE olmadığı gibi biliyorum.

Evet muhtemelen JNI bazı yerel kod yazarak bu erişebilirim. JNI Ara oldukça pahalı olduğu ortaya çıkıyor.

Bir JİT derleme ya da değil derlemek ne garanti edemezsin biliyorum. Herkes vardırhiçbu talimatları kullanan JİT üreten bir kod duydun mu? ve eğer, bu şekilde derlenebilir yardımcı olan Java kodu ile ilgili bir şey var mı?

""; Sormaya değer. hayır muhtemelen

Yani, temelde, kodunuzun daha hızlı çalışmasını istiyorum. JNI cevap. Sana yanıldığını işe yaramadı dedin, ama ben sana göstereyim biliyorum.

Burada Dot.java:

import java.nio.FloatBuffer;
import org.bytedeco.javacpp.*;
import org.bytedeco.javacpp.annotation.*;

@Platform(include="Dot.h", compiler="fastfpu")
public class Dot {
    static { Loader.load(); }

    static float[] a = new float[50], b = new float[50];
    static float dot() {
        float sum = 0;
        for (int i = 0; i < 50; i  ) {
            sum  = a[i]*b[i];
        }
        return sum;
    }
    static native @MemberGetter FloatPointer ac();
    static native @MemberGetter FloatPointer bc();
    static native float dotc();

    public static void main(String[] args) {
        FloatBuffer ab = ac().capacity(50).asBuffer();
        FloatBuffer bb = bc().capacity(50).asBuffer();

        for (int i = 0; i < 10000000; i  ) {
            a[iP] = b[iP] = dot();
            float sum = dotc();
            ab.put(iP, sum);
            bb.put(iP, sum);
        }
        long t1 = System.nanoTime();
        for (int i = 0; i < 10000000; i  ) {
            a[iP] = b[iP] = dot();
        }
        long t2 = System.nanoTime();
        for (int i = 0; i < 10000000; i  ) {
            float sum = dotc();
            ab.put(iP, sum);
            bb.put(iP, sum);
        }
        long t3 = System.nanoTime();
        System.out.println("dot(): "   (t2 - t1)/10000000   " ns");
        System.out.println("dotc(): "    (t3 - t2)/10000000   " ns");
    }
}

ve 7**:

float ac[50], bc[50];

inline float dotc() {
    float sum = 0;
    for (int i = 0; i < 50; i  ) {
        sum  = ac[i]*bc[i];
    }
    return sum;
}

Ve JavaCPP komutları kullanarak bu hat ile derleme yapabiliriz:

$ javac -cp javacpp.jar Dot.java
$ java -jar javacpp.jar Dot
$ java -cp javacpp.jar:. Dot

Intel Core i7-3632QM @ 2.20 GHz, Fedora 20, 4.8.3 ve OpenJDK 7 veya çıkış bu tür alıyorum 8, GCC İŞLEMCİ:

dot(): 37 ns
dotc(): 23 ns

Ya da yaklaşık 1.6 kat daha hızlı. Diziler yerine doğrudan NİO tamponlar kullanmamız gerekiyor, ama HotSpot can access direct NIO buffers as fast as arrays. Öte yandan, el ile döngü çözümü performans ölçülebilir bir destek, bu durumda sağlamaz.