小编dsi*_*cha的帖子

将内联汇编程序插入到类似C语言的函数中时,关于允许哪些寄存器用于临时的约定是什么？编译器是否有责任在进入asm块之前保存需要保存的所有寄存器的值？程序员是否有责任将值存储在这些寄存器中并在退出asm块之前恢复它们？是否有典型的约定,或者这是特定于实现的？

在关于垃圾收集是否是一件好事的神圣战争中,人们经常指出它不处理释放文件句柄之类的事情.将此逻辑放在终结器中被认为是一件坏事,因为资源会被非确定性地释放.然而,似乎一个简单的解决方案是操作系统只需要确保有大量的文件句柄可用,这样它们就是一种廉价而丰富的资源,你可以在任何给定的时间浪费一些.为什么这不是在实践中完成的？

是否有一个简单的(意思是没有滚动自己的排序函数)的方式来排序并行列表而不需要在Python 中进行不必要的复制？例如:

foo = range(5)
bar = range(5, 0, -1)
parallelSort(bar, foo)
print foo # [4,3,2,1,0]
print bar # [1,2,3,4,5]

我已经看过使用这些示例,zip但如果可以轻松避免将所有数据从并行列表复制到元组列表并再次返回,这似乎很愚蠢.

我正在开发一个项目,我需要存储一个由两个字符串键索引的数字矩阵.矩阵不是锯齿状的,即如果任何行都存在列密钥,那么它应该存在于所有行中.同样,如果任何列都存在行键,则它应存在于所有列中.

表达这一点的显而易见的方法是使用关联数组的关联数组,但这既笨拙又效率低,并且它不强制执行非锯齿状属性.是否有任何流行的编程语言提供了一种内置于语言中或作为标准库的一部分的关联矩阵？如果是这样,它们如何在API和实现级别上工作？我正在为这个项目使用Python和D,但是其他语言的例子仍然有用,因为我可以查看API并找出在Python或D中实现类似内容的最佳方法.

我在具有24个内核的共享Linux计算机上运行大规模并行的科学计算工作.大多数时候,当这台计算机上没有其他任何东西运行时,我的工作能够扩展到24个核心.然而,似乎即使一个不是我的单线程作业正在运行,我的24线程作业(我设置为高优值)只能获得~1800%的CPU(使用Linux表示法).同时,大约500%的CPU周期(再次使用Linux表示法)处于空闲状态.任何人都可以解释这种行为以及我能做些什么来获得所有其他人没有使用的核心？

笔记:

1. 如果它是相关的,我已经在稍微不同的内核版本上观察到了这一点,尽管我不记得哪个是我的头脑.

2. CPU架构是x64.我的24核作业是32位,而我正在竞争的其他作业是64位的这一事实是否有可能是相关的？

编辑:我刚注意到的一件事是,最多30个线程似乎在某种程度上缓解了这个问题.它让我高达2100%的CPU.

我经验丰富的剖析器(主要是带编译器的Digital Mars D剖面仪)似乎大大减慢了被编译程序的执行速度.这对我使用剖析器的意愿产生了重大影响,因为它使得剖析成为我的许多程序的"真实"运行,而不是在非常小的输入上进行测试,这是不切实际的.我不太了解如何实现分析器.在分析几乎是生活中的一个主要(> 2x)减速时,还是有避免它的剖析器？如果可以避免,有没有可用于D的快速分析器,最好是D2,最好是免费的？

我已经阅读了一些关于Python元类的教程.我之前从未使用过一个,但我需要一个相对简单的东西,所有的教程似乎都面向更复杂的用例.我基本上想要创建一个具有一些预先指定的主体的模板类,但是将其基类作为参数.因为我从C++/D模板中得到了这个想法,这里是我想要编写的代码在C++中的样子:

template<class T>
    class Foo : T {
        void fun() {}
    }

我有一个以下微小的Python方法,它是迄今为止性能热点(根据我的分析器,在这里花费了大约95%的执行时间)在一个更大的程序中:

def topScore(self, seq):
    ret = -1e9999
    logProbs = self.logProbs  # save indirection
    l = len(logProbs)
    for i in xrange(len(seq) - l + 1):
        score = 0.0
        for j in xrange(l):
            score += logProbs[j][seq[j + i]]
        ret = max(ret, score)

    return ret

代码是在Python的Jython实现中运行,而不是CPython,如果这很重要的话. seq是一个DNA序列串,大约有1,000个元素. logProbs是一个词典列表,每个位置一个.目标是找到任何长度l(大约10-20个元素)的子序列的最大分数seq.

我意识到所有这些循环由于解释开销而效率低下,并且在静态编译/ JIT语言中会更快.但是,我不愿意切换语言.首先,我需要一个JVM语言用于我正在使用的库,这种约束我的选择.其次,我不想将此代码批量转换为较低级别的JVM语言.但是,如果有必要,我愿意用其他东西重写这个热点,虽然我不知道如何连接它或者开销是多少.

除了这种方法的单线程缓慢之外,我还无法让程序在并行化方面超过4个CPU.鉴于它几乎所有的时间都花在我发布的10行热点上,我无法弄清楚这里的瓶颈是什么.

我希望通过添加一些启发式来改进D垃圾收集器,以避免垃圾收集运行,这不会导致显着的释放.我想补充的一种启发式方法是GC每X时间不应运行一次以上(可能每秒一次左右).为此,我需要一个具有以下属性的计时器:

1. 它必须能够以最小的开销获取正确的时间.调用core.stdc.time花费的时间大致相当于一个小的内存分配,因此它不是一个好的选择.

2. 理想情况下,应该是跨平台(OS和CPU),以简化维护.

3. 超高分辨率并不是非常重要.如果时间精确到1/4秒,这就足够了.

4. 必须在多线程/多CPU环境中工作.x86 rdtsc指令不起作用.

编辑:普通的旧C功能clock()似乎足够快.但是,这里溢出是一个问题.在32位Windows和Linux上,clock_t定义为32位有符号整数.当它溢出时,它是否变为负数,或者该clock()函数是否使用额外的逻辑使其换算为零？如果它包装为零,那么这将成功.如果它包装为负数(也代表错误代码等),那么它将不起作用.

编辑#2:无论如何我尝试了启发式,使用clock()和忽略溢出问题,就像测试一样.它的表现很差,不值得进一步调查.

我有一个场景,在我的程序中的某些点,线程需要更新几个共享数据结构.每个数据结构都可以与任何其他数据结构并行安全地更新,但每个数据结构一次只能由一个线程更新.我在代码中表达的简单,天真的方式是:

synchronized updateStructure1();
synchronized updateStructure2();
// ...

这似乎效率低下,因为如果多个线程正在尝试更新结构1,但没有线程尝试更新结构2,则它们都会阻塞等待保护结构1的锁,而结构2的锁则不会被取消.

是否有"标准"的方法来弥补这一点？换句话说,是否有一个标准的线程原语试图以循环方式更新所有结构,只有在采用所有锁定时才会阻塞,并在更新所有结构时返回？

这是一个与语言无关的问题,但如果有帮助,我使用的语言是D.