小编ein*_*ica的帖子

我有一个类，其 ctor 进行驱动程序调用，其 dtor 进行匹配的终止/释放驱动程序调用。这些调用可能会失败。问题自然出在 dtor 身上。

我自然知道避免 dtor 中出现异常的常识，因为如果您在堆栈展开期间抛出异常，您会得到std::terminate. 但是 - 如果可以的话，我宁愿不只是“吞下”此类错误并且不报告它们。那么，编写这样的代码是否合法/惯用：

~MyClass() noexcept(false) {
    auto result = something_which_may_fail_but_wont_throw();
    if (std::uncaught_exceptions() == 0) {
        throw some_exception(result);
    }
}

或者这只是巴洛克风格而不是一个好主意？

注意：此类无法访问标准输出/错误流，也无法访问日志等。

它是安全的代码，还是编译器可以通过 优化访问p，从而*p导致42？

#include <stdio.h>

int i = 42;
int *d = &i;

void test(int const *p) 
{
    *d = 43;
    printf("%d, %p\n", *p, (void *) p);
    printf("%d, %p\n", *d, (void *) d);
}

int main() {
    test(d);
    return 0;
}

我发现*p通常打印为43，但我想知道这里是否有任何陷阱，因此在某些情况下打印*p可能会产生42。

根据这篇文章, std :: cout会在\n连接到交互式设备(例如终端窗口)时自动刷新.否则(例如,当被管道传输到文件时)它将完全缓冲,并且只会刷新.flush()或std::endl.

有没有办法在Microsoft Visual C++中覆盖此行为,以便我可以选择是否需要完全缓冲或行缓冲模式？

创建CUDA事件时,您可以选择打开该cudaEventBlockingSync标志.但是 - 如果创建一个有或没有标志的事件之间的区别怎么办？我读了精美的手册 ; 它对我来说没有意义.什么是"调用主机线程",以及什么是"阻止" 不使用标志？

4.6.2.7 cudaError_t cudaEventSynchronize(cudaEvent_t事件)

直到事件实际被记录为止....等待使用cudaEventBlockingSync标志创建的事件 将导致调用主机线程阻塞,直到事件实际被记录为止.

我正在寻找一种方法来摆脱闲置代码中的主机线程中的繁忙等待（不复制该代码，它仅表示我的问题，它具有许多基本错误）：

cudaStream_t steams[S_N];
for (int i = 0; i < S_N; i++) {
    cudaStreamCreate(streams[i]);
}
int sid = 0;
for (int d = 0; d < DATA_SIZE; d+=DATA_STEP) {
     while (true) {
         if (cudaStreamQuery(streams[sid])) == cudaSuccess) { //BUSY WAITING !!!!
             cudaMemcpyAssync(d_data, h_data + d, DATA_STEP, cudaMemcpyHostToDevice, streams[sid]);
             kernel<<<gridDim, blockDim, smSize streams[sid]>>>(d_data, DATA_STEP);
             break;
         }
         sid = ++sid % S_N;
     }

}

有没有一种方法可以使主机线程空闲并以某种方式等待某个流完成，然后准备并运行另一个流？

编辑：我在代码中添加了while（true），以强调忙等待。现在，我执行所有流，并检查其中哪个流完成以运行另一个新流。cudaStreamSynchronize等待特定的流完成，但是我想等待首先完成工作的任何流。

EDIT2：我摆脱了以休闲方式的繁忙等待：

cudaStream_t steams[S_N];
for (int i = 0; i < S_N; i++) {
    cudaStreamCreate(streams[i]);
} …

我正在写一个CUDA内核,它涉及计算给定矩阵的最大值,我正在评估可能性.我能找到的最好方法是:

强制每个线程在共享内存中存储一​​个值,然后使用减少算法来确定最大值(pro:最小差异缺点:共享内存在2.0设备上限制为48Kb)

我无法使用原子操作,因为它有读取和写入操作,因此线程无法通过同步线程同步.

还有其他想法进入你的脑海吗？

在在线事件中,我们必须构建一个算法来生成如下所示的系列...,对于输入6,算法必须生成.....

123 624 693 4812 15510 12186.

我们对算法的想法很多而且非常沮丧.任何人都可以帮助我们......

编辑:得到算法.感谢Irit katriel

我在这里遇到一些问题,我不是百分之百理解:

let x = 1 in let x = x+2 in let x = x+3 in x

我知道这个表达式的结果是6,但只是想确定计算这个表达式的顺序; 首先计算哪部分？

这是我的代码：

struct S {
    int a, b;
    float c, d;
};
class A {
private:
    S* d;
    S h[3];
public:
    A() {
        cutilSafeCall(cudaMalloc((void**)&d, sizeof(S)*3));
    }
void Init();
};

void A::Init() {
    for (int i=0;i<3;i++) {
        h[i].a = 0;
        h[i].b = 1;
        h[i].c = 2;
        h[i].d = 3;
    }
    cutilSafeCall(cudaMemcpy(d, h, 3*sizeof(S), cudaMemcpyHostToDevice));
}

A a;

事实上它是一个包含CUDA和OpenGL的复杂程序。当我调试这个程序时，在 cudaMemcpy 上运行时失败并显示错误信息

cudaSafeCall() 运行时 API 错误 11：参数无效。

实际上，这个程序是由另一个可以正确运行的程序改造而来的。但在那一例中，我在主函数中而不是在类中使用了两个变量 S* d 和 Sh[3]。更奇怪的是我在一个小程序中实现了这个A类，它运行得很好。我已经更新了驱动程序，错误仍然存​​在。

谁能给我提示为什么会发生这种情况以及如何解决它。谢谢。

我发现英特尔的Thread Building Blocks库令人困惑.例如,我想使用TBB并行化以下计算:

int CountNegatives(std::vector<Trigraph> input)
{
    int count = 0;
    for(int i = 0; i< input.size(); i++)
    {
        if(input[i].VisibleFrom(viewPoint))
        {
            count++;
        }
    }
    return count;
}

我知道你必须operator()在TBB中使用一个类来做到这一点; 真的吗？我本来希望在TBB上阅读一些"初学者教程",以帮助我解决这个问题,但似乎没有任何初学者教程.

你能帮我把TBB应用到这个计算中吗？