小编Zis*_*Zis的帖子

我想知道为什么在 PyTorch 中固定内存会使事情变得更慢。通过阅读 的代码torch.utils.data.dataloader，我找到了在返回之前简单地调用每个批次的pin_memory=True选项。返回的张量仍在 CPU 上，此后我必须手动调用。因此，整个过程将是DataLoader.pin_memory().cuda(non_blocking=True)

for x in some_iter:
    yield x.pin_memory().cuda(non_blocking=True)

我将其性能与

for x in some_iter:
    yield x.cuda()

这是实际的代码

a = torch.rand(1024, 655360)

%%time
for i in a:
    i.pin_memory().cuda(non_blocking=True)
# CPU times: user 1.35 s, sys: 55.8 ms, total: 1.41 s
# Wall time: 396 ms

%%time
for i in a:
    i.pin_memory().cuda()
# CPU times: user 1.6 s, sys: 12.2 ms, total: 1.62 s
# Wall time: 404 ms

%%time
for i …

我试过了:

let mut vec = [1,2,3];

for mut x in &vec { *x=3; }
for mut &x in &vec { x=3; }
for mut *x in &vec { x=3; }
for mut x in mut &vec { *x=3; }
for mut x in &(mut vec) { *x=3; }

这些都不起作用; 我该怎么办？

我正在实现一些搜索算法，numpy其中一个步骤是检查向量是否在矩阵中（作为行）。我以前用过np.isin，但我突然很好奇 python 关键字是否in有效。因此我对其进行了测试，发现它确实有效。

由于我没有找到任何 python 接口in（例如__add__for+或__abs__for abs），我相信in通过使用标准迭代器逻辑在 python 中进行硬连接，因此它应该比 -providednumpy慢np.isin。但在我做了一些测试之后，令人难以置信的是：

>>> a = np.int8(1)\n>>> A = np.zeros(2**24, \'b\')\n>>> %timeit a in A\n>>> %timeit np.isin(a, A)\n21.7 ms \xc2\xb1 1.58 ms per loop (mean \xc2\xb1 std. dev. of 7 runs, 10 loops each)\n310 ms \xc2\xb1 20.4 ms per loop (mean \xc2\xb1 std. dev. of 7 runs, 1 loop each)\n …

例如,如果我有以下代码:

int main(){
  myClass a(...);
  a.doSomething();
  if(...){
    myClass c(...);
    c.doSomething();
  }
}

像gcc或clang这样的通常编译器会优化这些变量的使用,发现"a"在它的生命周期中将不再使用,而不是为"c"重新分配空间,只需使用空间？如果这对于类不起作用,那么对于像double或size_t这样的"传统"类型是否有效？

我正在尝试最小化频繁调用函数的分配成本.但是在函数内部的某个地方,我觉得一些旧的变量已经没用了,但新变量不应该被称为该名称.编译器会直接重用变量给我,还是应该做类似的事情

myClass a(...);
something(a);
if(...){
  #define c a
  c=myClass(...);
  something c;
  #undef c
}

我正在尝试实现一个多入多出的线程间通道类。我有三个互斥锁：full缓冲区已满时锁定。empty当缓冲区为空时锁定。th当其他人正在修改缓冲区时锁定。我的单个 IO 程序看起来像

operator<<(...){
  full.lock()        // locks when trying to push to full buffer
  full.unlock()      // either it's locked or not, unlock it
  th.lock()
  ...
  empty.unlock()     // it won't be empty
  if(...)full.lock() // it might be full
  th.unlock()
operator>>(...){
  // symmetric
}

这对于单个 IO 完全适用。但是对于多个 IO，当消费者线程解锁时full，所有提供者线程都会关闭，只有一个会获取th并且缓冲区可能会因为单个线程而再次变满，而不再进行完整检查。我full.lock()当然可以再次添加，但这是无止境的。反正是有锁full，并th在同一时间？我确实看到了一个类似的问题，但我没有看到这里的问题是订单。