摩尔定律问题

时间:2008-12-10 14:24:42

标签: moores-law

假设您需要在世界上最快的超级计算机上运行程序,这需要10年才能完成。你可以:

  • 现在花费2.5亿美元
  • 计划9年,Moore’s law加速(快4,000倍),10年内花费100万美元,2周内完成。

什么是最佳策略?

来自“Long Term Storage Trends and You”的问题

12 个答案:

答案 0 :(得分:11)

Moore's Law与速度无关,它与硅的给定区域中的晶体管数量有关。无法保证在9年内速度将提高4000倍。如果有的话,近年来GHz的速度已经稳定下来。目前,正在增加的是CPU中的核心数量。

在你的问题中,如果程序不适合矢量化(即可以分成可以并行计算的不同部分),那么等待9年不会带来任何好处,它就不会那么快在此期间,时钟速度不太可能提高。

答案 1 :(得分:7)

假设程序是无限可并行化的(因此它总是可以利用所有可用CPU的所有内核)...
假设程序无法暂停并在中途运行到另一台机器上...
假设时间是唯一的问题(也许我们有大量的研究经费,而且我们总是使用最好的计算机)......

我们有四个等式(好吧,实际上有两个是函数):

  1. endtime(startyear) = startyear + (calculations / speed(startyear))
  2. speed(year) = speed(year-1.5) 4 (该问题假定硬件和软件每18个月加速一次)
  3. endtime(0) = 0 + (calculations/speed(0)) = 10 years
  4. speed(0) = calculations/(10 years)(暗示为#3)
  5. 我开始使用衍生工具来减少终结时间,但我意识到我不能很好地记住我的微分方程。所以我将#2转换为equivalent exponential-growth formula

      

    speed(year) = speed(0)*4 (年/ 1.5) = (calculations/10)*4 (年/ 1.5)

    然后我写了这个小BeanShell脚本:

    calculations() {
        return 10000000; // random constant (gets cancelled out anyway)
    }
    speed(year) {
        speed0 = calculations()/10; // constant factor
        return speed0*Math.pow(4.0, year/1.5);
    }
    endtime(startyear) {
        return startyear + calculations()/speed(startyear);
    }
    findmin() {
        start = 0.0;
        finish = 10.0;
        result = 0.0;
        // home in on the best solution (there should only be one minimum)
        for (inc = 1; inc > 0.00000001; inc /= 2.0) {
            result = findmin(start,finish,inc);
            start = result-2*inc;
            finish = result+inc;
        }
        print("Minimum value is " + result + ", taking a total of " +
                endtime(result) + " years");
    }
    findmin(start,finish,inc) {
        lastNum = 0;
        lastVal = Double.MAX_VALUE;
        for (i = start; i < finish; i += inc) {
            result = endtime(i);
            if (result > lastVal) {
                print("Minimum value between " + start + " and " + finish +
                        " is " + lastVal + ", occurring at " + lastNum);
                return i;
            }
            lastNum = i;
            lastVal = result;
        }
        return lastNum;
    }
    

    输出:

    bsh % source("moore.bsh");
    bsh % findmin();
    Minimum value between 0.0 and 10.0 is 3.5749013123685915, occurring at 2.0
    Minimum value between 1.0 and 4.0 is 3.4921256574801243, occurring at 2.5
    Minimum value between 2.0 and 3.5 is 3.4921256574801243, occurring at 2.5
    Minimum value between 2.25 and 3.0 is 3.4886233976754246, occurring at 2.375
    Minimum value between 2.25 and 2.625 is 3.488620519067143, occurring at 2.4375
    Minimum value between 2.375 and 2.5625 is 3.488170701257679, occurring at 2.40625
    Minimum value between 2.375 and 2.46875 is 3.488170701257679, occurring at 2.40625
    Minimum value between 2.390625 and 2.4375 is 3.488170701257679, occurring at 2.40625
    (snip)
    Minimum value between 2.406149387359619 and 2.4061494767665863 is 3.4881706965827037,
    occurring at 2.4061494171619415
    Minimum value is 2.4061494320631027, taking a total of 3.488170696582704 years
    

    因此,根据我之前所说的假设,答案是等待 2.406149 ...年(或大约 2年,148天,根据谷歌的说法)。


    编辑:我注意到,如上所述重写第二个公式,求解只需要简单的微积分。

    endtime(x) = x + c/speed(x) (where c = calculations)
    speed(x) = speed(0) * 4^(x/1.5) = (c/10)*4^(2x/3)
    => endtime(x) = x + c/((c/10)*4^(2x/3))
                  = x + 10*(4^(-2x/3))
    d/dx endtime(x) = 1 + 10*ln(4)*(-2/3)*(4^(-2x/3))
    

    Critical point是d / dx = 0,所以

    1 + 10*ln(4)*(-2/3)*(4^(-2x/3)) = 0
    => 4^(-2x/3) = 1/(10*ln(4)*(2/3))
    

    采取双方的log4 :(记住log4(x) = ln(x)/ln(4)ln(1/x) = -ln(x)

    -2x/3 = ln(1/(10*ln(4)*(2/3))) / ln(4)
          = -ln(10*ln(4)*2/3) / ln(4)
    => x = (-3/2) * -ln(1/(10*ln(4)*2/3)) / ln(4)
         = 3*ln(10*ln(4)*(2/3)) / 2*ln(4)
    

    这看起来像是一个糟糕的混乱(这没有帮助,没有好方法来显示数学公式)。但如果你把它插入你的计算器,你应该得到 2.4061494159159814141268120293221 (至少如果你使用Windows计算器,就像我刚才那样)。所以我之前的答案对于七位小数是正确的(当然这在像这样的问题中毫无意义)。

    (我应该注意,这只是一个关键点,不一定是最小值。但是二阶导数(其形式为-(some constant)*4 -2x / 3 )总是负的因此,函数总是凹陷,因此唯一的关键点是最小值。)

答案 2 :(得分:4)

Moore's Law关注的是将放置在一个芯片中的晶体管数量与微处理器的速度无关。 / p>

也就是说,从我们目前看到的趋势来看,我们可能会看到越来越多的内核适合单个处理器芯片,因此并发编程对于利用原始处理能力将变得越来越重要可在处理器中使用。

所以,现在很难说是现在还是等待 - 但无论如何,并发编程或分布式计算将会发挥作用,因为我们不会由于当前半导体技术的物理限制和自然规律,看到单个核心处理器变得指数级更快(就时钟速度而言)。

答案 3 :(得分:3)

确保您的程序可以暂停并继续,然后在它们出现时将它放在速度越来越快的机器上。两全其美...

答案 4 :(得分:1)

现在花钱 - 现在美元的价格/价值与10年的估计相比,就像试图预测3个月后的天气一样。此外,这还没有考虑10年内编程趋势等因素,以及事情是否真的会快4,000倍或可扩展/并行4,000倍,这似乎是最近的趋势。

另外,根据玛雅人的说法,世界将在2012年结束,所以现在就用掉战利品!

答案 5 :(得分:1)

简化模型以估算您现在可以运行。随着更多/更好的资源可用,请优化模型以获得更准确的结果。

答案 6 :(得分:1)

完成它的最快方法是:

  • 编写可以迁移到每个新一代的当前技术的版本。
  • 除了迁移之外,还要继续通过算法编程进行任何改进等。

最便宜的方式显然是延长时间。你需要考虑编程时间(这将足够接近恒定)。

另外,我不想过分依赖摩尔定律。

还要记住,摩尔定律与晶体管的密度有关,而不是与特定问题的计算速度有关。即使计算能力总体上提高了很多,也不一定意味着您的应用程序将受益。

答案 7 :(得分:0)

问题中指出问题是在超级计算机上运行,​​因此问题必须是可矢量化的。超级计算机的速度比摩尔定律快得多,因此根据实际的问题空间,一种方法是聘请黑客强盗来创建一个全球分布的沃霍尔蠕虫,它获得了85%的计算机资源在网上进行短暂的大规模分布式网格,如梅森素数搜索(GIMPS),并在20分钟内解决问题。

(解决问题的方法很多,但我确定希望将其标记为幽默)

答案 8 :(得分:0)

但摩尔定律并没有加快编程速度。

9年的编程永远不会缩短为2周。

除非你成功花了9年时间编写一台自动思维阅读机,我想。

答案 9 :(得分:0)

计划4年,然后在2.5?

运行

(我确信在4到5年之间有一个“完美”的答案......)

答案 10 :(得分:0)

最佳策略取决于您必须运行程序的原因。

在这种情况下,第二个选项是最好的选项,因为你得到结果的那一刻(这实际上是重要的)将是相同的。

实际上,我相信如果每个人都选择第一个(并且有钱做到这一点)......摩尔定律会受到损害。我假设如果我们所有的计算需求都得到满足......我们就不会那么致力于保持技术发展的进步。

答案 11 :(得分:0)

这是一个有缺陷的假设,即摩尔定律实际上是一个定律。它可能更好地命名为摩尔的理论。你等待的风险是,在10年内,它可能还需要10年才能运行。立即启动程序(如果可能的话,暂停并重新启动),启动一个团队,寻找其他方法来解决问题,这将更快。一旦您确信其中一个或另一个将提供更快的解决方案,请切换。

编辑:作为一个问题,我认为这个问题的最大价值在于它会让你检查你的假设是否有效。显而易见的解决方案 - 因为根据问题定义,您可以在相同的时间内以较少的资金获得相同的结果 - 等待,但这取决于一些隐含的假设。如果这些假设不成立,那么显而易见的解决方案并不一定是最好的,因为这里的许多答案都证明了这一点。

豫ICP备18024241号-1