标签: jit

以下Java程序平均需要在0.50到0.55之间运行:

public static void main(String[] args) {
    long startTime = System.nanoTime();
    int n = 0;
    for (int i = 0; i < 1000000000; i++) {
        n += 2 * (i * i);
    }
    System.out.println((double) (System.nanoTime() - startTime) / 1000000000 + " s");
    System.out.println("n = " + n);
}

如果我更换2 * (i * i)用2 * i * i,它需要0.60〜0.65s之间运行.怎么会？

我运行了每个版本的程序15次,在两者之间交替.结果如下:

 2*(i*i)  |  2*i*i
----------+----------
0.5183738 | 0.6246434
0.5298337 | 0.6049722
0.5308647 | 0.6603363
0.5133458 | 0.6243328
0.5003011 | …

我一直听到很多关于PyPy项目的消息.他们声称它比他们网站上的CPython解释器快6.3倍.

每当我们谈论像Python这样的动态语言时,速度是最重要的问题之一.为了解决这个问题,他们说PyPy的速度要快6.3倍.

第二个问题是并行性,臭名昭着的全球口译锁(GIL).为此,PyPy表示它可以提供无GIL的Python.

如果PyPy可以解决这些巨大的挑战,它的弱点是什么阻碍了更广泛的采用？也就是说,什么阻止像我这样的人,一个典型的Python开发人员,现在切换到PyPy ？

与非JIT编译器相比,JIT编译器具体做什么？有人可以给出一个简洁易懂的描述吗？

在Visual Studio中运行发行版并在Visual Studio外部运行发行版时,以下代码提供了不同的输出.我正在使用Visual Studio 2008并以.NET 3.5为目标.我也尝试过.NET 3.5 SP1.

当在Visual Studio外部运行时,JIT应该启动.或者(a)C#中有一些微妙的东西我缺失或者(b)JIT实际上是错误的.我怀疑JIT可能出错,但我已经没有其他可能性......

在Visual Studio中运行时输出:

    0 0,
    0 1,
    1 0,
    1 1,

在Visual Studio外部运行发布时的输出:

    0 2,
    0 2,
    1 2,
    1 2,

是什么原因？

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Test
{
    struct IntVec
    {
        public int x;
        public int y;
    }

    interface IDoSomething
    {
        void Do(IntVec o);
    }

    class DoSomething : IDoSomething
    {
        public void Do(IntVec o)
        {
            Console.WriteLine(o.x.ToString() + " " + o.y.ToString()+",");
        }
    }

    class Program
    { …

我标杆一些代码,我不能让它以最快的速度奔跑着java.math.BigInteger使用完全相同的算法,即使.所以我将java.math.BigIntegersource 复制到我自己的包中并尝试了这个:

//import java.math.BigInteger;

public class MultiplyTest {
    public static void main(String[] args) {
        Random r = new Random(1);
        long tm = 0, count = 0,result=0;
        for (int i = 0; i < 400000; i++) {
            int s1 = 400, s2 = 400;
            BigInteger a = new BigInteger(s1 * 8, r), b = new BigInteger(s2 * 8, r);
            long tm1 = System.nanoTime();
            BigInteger c = a.multiply(b);
            if (i > 100000) {
                tm += System.nanoTime() - tm1; …

Sun的规范JVM实现将一些非常复杂的优化应用于字节码,以便在代码运行几次后获得接近本机的执行速度.

问题是,为什么这个编译的代码没有缓存到磁盘上以便在后续使用同一个函数/类时使用？

就目前而言,每次执行程序时,JIT编译器都会重新启动,而不是使用预编译版本的代码.当字节码基本上被解释时,不会添加此功能会大大增加程序的初始运行时间吗？

假设我的Java程序的瓶颈确实是计算一堆矢量点积的一些紧密循环.是的我已经分析过,是的,它是瓶颈,是的,它是重要的,是的,这就是算法是什么,是的,我运行Proguard来优化字节码等.

这项工作基本上是点产品.因为,我有两个float[50],我需要计算成对产品的总和.我知道处理器指令集可以快速和批量地执行这些操作,如SSE或MMX.

是的我可以通过在JNI中编写一些本机代码来访问它们.JNI电话证明非常昂贵.

我知道你无法保证JIT编译或编译的内容.有没有人曾经听说过使用这些指令的JIT生成的代码？如果有的话,有什么关于Java代码可以帮助它以这种方式编译吗？

可能是"不"; 值得一提.

我正在阅读一篇文档,其中讨论了Java的即时编译器(JIT)优化技术.其中一个是"循环反转".文件说:

用while循环替换常规do-while循环.而 do-while循环的中设置if条款.这种替换可以减少两次跳跃.

循环反转如何工作以及它如何优化我们的代码路径？

注意: 如果有人可以用Java代码的例子解释JIT如何将其优化为本机代码以及为什么它在现代处理器中是最佳的,那将是很好的.

简介: 我用C#编写高性能代码.是的,我知道C++会给我更好的优化,但我仍然选择使用C#.我不想辩论这个选择.相反,我想听听那些像我一样试图在.NET Framework上编写高性能代码的人.

问题:

• 为什么下面的代码中的运算符比等效的方法调用慢？
• 为什么在下面的代码中传递两个双精度的方法比传递一个内部有两个双精度的结构的等效方法更快？(答:较旧的JIT优化结构很差)
• 有没有办法让.NET JIT编译器像结构的成员一样有效地处理简单的结构？(答:获得更新的JIT)

我想我知道: 原始的.NET JIT编译器不会内联涉及结构的任何内容.奇怪的给定结构只应该用于需要像内置函数那样优化的小值类型的情况,但是确实如此.幸运的是,在.NET 3.5SP1和.NET 2.0SP2中,他们对JIT Optimizer进行了一些改进,包括对内联的改进,特别是对于结构.(我猜他们这样做是因为否则他们引入的新的Complex结构会表现得非常糟糕......所以复杂团队可能会对JIT Optimizer团队产生影响.)因此,.NET 3.5 SP1之前的任何文档都可能是与这个问题不太相关.

我的测试显示: 我已经通过检查C:\ Windows\Microsoft.NET\Framework\v2.0.50727\mscorwks.dll文件的版本> = 3053来验证我有更新的JIT优化器,所以应该有这些改进到JIT优化器.然而,即便如此,我的拆卸时间和外观都表明:

用于传递具有两个双精度的结构的JIT生成的代码远不如直接传递两个双精度的代码有效.

与传递struct作为参数相比,JIT生成的struct方法代码传递'this'的效率要高得多.

如果你传递两个双打而不是传递一个带有两个双精度的结构,JIT仍然可以更好地内联,即使是由于明显在循环中的乘数.

时间: 实际上,看看反汇编,我意识到循环中的大部分时间只是从List中访问测试数据.如果分解循环的开销代码和访问数据,则进行相同调用的四种方法之间的差异会大不相同.对于PlusEqual(double,double)而不是PlusEqual(Element),我可以获得5倍到20倍的加速比.使用PlusEqual(double,double)代替运算符+ = 10x到40x.哇.伤心.

这是一组时间:

Populating List<Element> took 320ms.
The PlusEqual() method took 105ms.
The 'same' += operator took 131ms.
The 'same' -= operator took 139ms.
The PlusEqual(double, double) method took 68ms.
The do nothing loop took 66ms.
The ratio of operator with constructor to method is 124%.
The ratio of operator without constructor to …

我正在编写一个编写JIT编译器的想法,我只是想知道理论上是否有可能在托管代码中编写整个东西.特别是,一旦你将汇编程序生成为字节数组,你如何跳转到它开始执行？