相关疑难解决方法(0)

我有一个byte[4096]并且想知道检查所有值是否为零的最快方法是什么？

有没有比做更快的方法:

byte[] b = new byte[4096];
b[4095] = 1;
for(int i=0;i<b.length;i++)
    if(b[i] != 0)
        return false; // Not Empty

一些相关的问题和一年之久:JVM的JIT编译器是否生成使用向量化浮点指令的代码？

前言:我试图在纯java中执行此操作(没有JNI到C++,没有GPGPU工作等等).我已经进行了分析,并且大部分处理时间来自此方法中的数学运算(可能是95%的浮点数学运算和5%的整数运算).我已经将所有Math.xxx()调用减少到足够好的近似值,因此大部分数学运算现在都是浮点数乘以一些加法.

我有一些处理音频处理的代码.我一直在进行调整,并且已经获得了巨大的收益.现在我正在研究手动循环展开以查看是否有任何好处(至少手动展开2,我看到大约25%的改进).在尝试手动展开4时(由于我展开嵌套循环的两个循环,这开始变得非常复杂)我想知道是否有任何我可以做的提示到jvm在运行时它可以使用向量操作(例如SSE2,AVX等......).音频的每个样本都可以完全独立于其他样本计算,这就是为什么我已经能够看到25%的改进(减少浮点计算的依赖性).

例如,我有4个浮点数,循环的4个展开中的每一个都有一个浮点数来保存部分计算的值.我如何声明和使用这些浮子很重要吗？如果我把它变成一个浮点数[4],它会向jvm暗示它们彼此无关,而不是浮动,浮动,浮动,浮动甚至是一类4个公共浮标？有什么我可以做的没有意义,这会杀死我的代码被矢量化的机会？

我在网上看到有关"正常"编写代码的文章,因为编译器/ jvm知道常见模式以及如何优化它们并偏离模式可能意味着更少的优化.至少在不过这种情况下,我也没有想到2展开环之多具有改进的性能,因为它没有,所以我想知道如果有什么我可以做的(或至少不这样做),以帮助我机会.我知道编译器/ jvm只会变得更好所以我也要警惕做将来会伤害我的事情.

编辑为好奇:4展开的提高性能的另一个〜25%,比展开了2,所以我真的觉得向量运算会在我的情况下帮助如果JVM支持它(或者是已经被使用它们).

谢谢!

我最近看到多个声明,谈论Java(以及基于JVM的语言,如Scala)在性能上与C/C++代码的可比性.

例如,从ScalaLab项目的描述:

基于Scala的脚本编写速度,接近本机和优化Java代码的速度,因此与基于C/C++的科学代码接近甚至更好!

有人能指出我对这些JVM优化的概述吗？是否有任何真正的基准支持这一主张或提供一些真实的比较？

如何使用Java的Intel i7 Vector处理器(AVX)？这是一个简单的问题,但答案似乎很难找到.

我正在研究用Java计算昂贵的向量运算的方法,例如点积或大矩阵之间的乘法.关于这个主题,这里有一些好的主题,比如这个和这个.

似乎没有可靠的方法让JIT编译代码使用CPU向量指令(SSE2,AVX,MMX ......).此外,高性能线性代数库(ND4J,jblas,...)实际上对核心例程进行了对BLAS/LAPACK库的JNI调用.我理解BLAS/LAPACK包是本机线性代数计算的事实上的标准选择.
另一方面,其他人(JAMA,...)在没有native调用的情况下在纯Java中实现算法.

我的问题是:

• 这里的最佳做法是什么？
• 正在native对BLAS/LAPACK实际上是一个推荐选择电话？还有其他值得考虑的图书馆吗？
• 与性能增益相比,JNI调用的开销是否可忽略不计？有没有人有关于阈值所在的经验(例如,输入应该使JNI调用比纯Java例程更昂贵？)
• 可移植性权衡有多大？

我希望这个问题既可以帮助那些开发自己的计算程序的人,也可以帮助那些只想在不同实现之间做出明智选择的人.

深刻见解!

我使用Javacv代码在Andorid中制作了一个自定义相机.我没有包含所有.so文件,只包括我的应用程序所需的文件.如下面的屏幕截图:

它适用于Samsumg Galaxy S2,S3和索尼爱立信Xperia Arc.没问题.但是,当我试图在三星P7500 Galaxy Tab 10.1上运行它时,它崩溃了我使用的第一行Javacv代码,恰好是:

yuvIplImage = IplImage.create(previewWidth, previewHeight,  IPL_DEPTH_8U, 2);

此尝试的Logcat输出:

07-08 13:30:13.930: I/ActivityManager(192): START {intent.toShortString} from pid 7836
07-08 13:30:14.000: I/ActivityManager(192): Start proc app.processName for activity hostingNameStr: pid=7847 uid=10001 gids={1006, 3003, 1015, 1023}
07-08 13:30:14.190: D/NvOsDebugPrintf(116): GetParameter(): 37 not supported
07-08 13:30:14.190: E/NvOmxCameraSettingsParser(116): Param type 71 not supported
07-08 13:30:14.240: W/dalvikvm(7847): VFY: unable to resolve virtual method 18783: Ljava/awt/image/BufferedImage;.getSampleModel ()Ljava/awt/image/SampleModel;
07-08 13:30:14.250: D/dalvikvm(7847): VFY: replacing opcode 0x22 at 0x0007
07-08 13:30:14.250: W/dalvikvm(7847): VFY: …

我有小矢量.它们中的每一个都由10个整数组成,这些整数介于0和15之间.这意味着矢量中的每个元素都可以使用4位写入.因此,我可以连接我的向量元素并将整个向量存储在单个long类型中(在C,C++,java ...中)

如果对于0,...,9,v1 [i]> = v2 [i]中的每个i,向量v1支配向量v2

我想写一个方法compare(long v1, long v2),如果非向量支配另一个,则返回0,如果第一个占优势,则返回1,如果第二个占优势,则返回-1.

除了获得每个i组件并进行正常整数比较的10倍之外,还有任何有效的方法来实现比较吗？

编辑

如果v1与v2完全相同则返回1或-1都很好

这部分代码来自我的矢量类的dotproduct方法.该方法对目标矢量数组(1000个矢量)进行内积计算.

当向量长度为​​奇数(262145)时,计算时间为4.37秒.当向量长度(N)为262144(8的倍数)时,计算时间为1.93秒.

     time1=System.nanotime();
     int count=0;
     for(int j=0;j<1000;i++)
     {

             b=vektors[i]; // selects next vector(b) to multiply as inner product.
                           // each vector has an array of float elements.

             if(((N/2)*2)!=N)
             {
                 for(int i=0;i<N;i++)
                 {
                     t1+=elements[i]*b.elements[i];
                 }
             }
             else if(((N/8)*8)==N)
             {
                 float []vek=new float[8];
                 for(int i=0;i<(N/8);i++)
                 {
                     vek[0]=elements[i]*b.elements[i];
                     vek[1]=elements[i+1]*b.elements[i+1];
                     vek[2]=elements[i+2]*b.elements[i+2];
                     vek[3]=elements[i+3]*b.elements[i+3];
                     vek[4]=elements[i+4]*b.elements[i+4];
                     vek[5]=elements[i+5]*b.elements[i+5];
                     vek[6]=elements[i+6]*b.elements[i+6];
                     vek[7]=elements[i+7]*b.elements[i+7];


                     t1+=vek[0]+vek[1]+vek[2]+vek[3]+vek[4]+vek[5]+vek[6]+vek[7];
                     //t1 is total sum of all dot products.
                 }
             }
     }
     time2=System.nanotime();
     time3=(time2-time1)/1000000000.0; //seconds

问题:将时间从4.37s减少到1.93s(快2倍)是JIT明智地决定使用SIMD指令还是只是我的循环展开的正面效果？

如果JIT不能自动进行SIMD优化,那么在这个例子中,JIT也没有自动完成展开优化,这是真的吗？

对于1M迭代(向量)和向量大小为64,加速乘数变为3.5X(缓存优势？).

谢谢.

我最近决定尝试一下 Java 的新孵化矢量 API，看看它能达到多快。我实现了两种相当简单的方法，一种用于解析 int，另一种用于查找字符串中字符的索引。在这两种情况下，与标量方法相比，我的矢量化方法都慢得令人难以置信。

这是我的代码：

public class SIMDParse {

private static IntVector mul = IntVector.fromArray(
        IntVector.SPECIES_512,
        new int[] {0, 0, 0, 0, 0, 0, 1000000000, 100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10, 1},
        0
);
private static byte zeroChar = (byte) '0';
private static int width = IntVector.SPECIES_512.length();
private static byte[] filler;

static {
    filler = new byte[16];
    for (int i = 0; i < 16; i++) {
        filler[i] = zeroChar;
    }
}

public static int parseInt(String str) …

编辑:考虑到第一个答案我删除了"myexp()"函数,因为bug而不是讨论的要点

我有一段简单的代码,为不同的平台编译并获得不同的性能结果(执行时间):

• Java 8/Linux:3.5秒

  执行命令: java -server Test

• C++/gcc 4.8.3:6.22秒

  编译选项: O3

• C++/Visual Studio 2015:1.7秒

  编译器选项: /Og /Ob2 /Oi

似乎VS有这些额外的选项不适用于g ++编译器.

我的问题是:为什么Visual Studio(带有那些编译器选项)在Java和C++方面都更快(使用O3优化,我相信这是最先进的)？

您可以在下面找到Java和C++代码.

C++代码:

#include <cstdio>
#include <ctime>
#include <cstdlib>
#include <cmath>


static unsigned int g_seed;

//Used to seed the generator.
inline void fast_srand( int seed )
{
    g_seed = seed;
}

//fastrand routine returns one integer, similar output value range as C lib.
inline int fastrand()
{
    g_seed = ( 214013 * g_seed + 2531011 );
    return ( …